local 战斗准备类 = class()
模型库1 = {
	"沙僧",
	"孙悟空",
	"猪八戒",
	"地涌夫人",
	"二郎神",
	"巫奎虎",
	"程咬金",
	"东海龙王",
	"孙婆婆",
	"牛魔王",
	"镇元大仙",
	"菩提祖师",
	"白晶晶",
	"李靖",
	"地藏王",
	"大大王",
	"观音姐姐",
	"空度禅师",
	"周杰伦",
	"二大王",
	"进阶二大王",
	"红孩儿",
	"进阶红孩儿",
	"春十三娘",
	"进阶春十三娘",
	"白骨精",
	"进阶白骨精",
	"广目天王",
	"进阶广目天王",
	"新猪八戒",
	"进阶新猪八戒",
	"紫霞",
	"进阶紫霞",
	"新孙悟空",
	"进阶新孙悟空",
	"剑灵双子",
	"进阶剑灵双子",
	"红衣战锤使",
	"进阶红衣战锤使",
	"美猴王",
	"进阶美猴王",
	"狗头人",
	"进阶狗头人",
	"巨灵狼",
	"进阶巨灵狼",
	"黑翼弓使",
	"进阶黑翼弓使",
	"无名上仙",
	"进阶无名上仙",
	"光辉女神",
	"进阶光辉女神",
	"四翼上仙",
	"进阶四翼上仙",
	"大象精",
	"进阶大象精",
	"四臂魔神",
	"进阶四臂魔神",
	"老鹰精",
	"进阶老鹰精",
	"氪金大佬",
	"进阶氪金大佬",
	"超级三眼娃",
	"进阶超级三眼娃",
	"太极真君",
	"进阶太极真君",
	"托塔娃",
	"进阶托塔娃",
	"巨斧猛男",
	"进阶巨斧猛男",
	"齐天大圣",
	"进阶齐天大圣",
	"酷炫佬",
	"进阶酷炫佬",
	"酷炫老逼登",
	"进阶酷炫老逼登",
	"风火轮器灵",
	"进阶风火轮器灵",
	"鲛人鱼",
	"进阶鲛人鱼",
	"蚩尤武魂",
	"进阶蚩尤武魂",
	"神武风伯",
	"进阶神武风伯",
	"熊猫大侠",
	"进阶熊猫大侠",
	"拽王",
	"进阶拽王",
	"剑仙",
	"进阶剑仙",
	"判官",
	"进阶判官",
	"龙羽",
	"进阶龙羽",
	"罗汉",
	"进阶罗汉",
	"龙王",
	"进阶龙王",
	"天师",
	"进阶天师",
	"战将",
	"进阶战将",
	"狂狮",
	"进阶狂狮",
	"佛子",
	"进阶佛子",
	"葫仙",
	"进阶葫仙",
	"法僧",
	"进阶法僧",
	"金衣仙",
	"进阶金衣仙",
	"龙剑士",
	"进阶龙剑士",
	"龙剑女",
	"进阶龙剑女",
	"水龙",
	"进阶水龙",
	"画仙",
	"进阶画仙",
	"天帝",
	"进阶天帝",
	"镇元",
	"进阶镇元",
	"鬼君",
	"进阶鬼君",
	"鹿君",
	"进阶鹿君",
	"火女",
	"进阶火女",
	"福禄仙",
	"进阶福禄仙",
	"天后",
	"进阶天后",
	"太极老君",
	"进阶太极老君",
	"天兵统领",
	"进阶天兵统领",
	"阎王爷",
	"进阶阎王爷",
	"赵云",
	"进阶赵云",
	"紫霞仙子",
	"进阶紫霞仙子",
	"阿朱",
	"进阶阿朱",
	"白子画",
	"进阶白子画",
	"貂蝉",
	"进阶貂蝉",
	"凤九",
	"进阶凤九",
	"关羽",
	"进阶关羽",
	"花无缺",
	"进阶花无缺",
	"剑圣",
	"进阶剑圣",
	"巨灵神",
	"进阶巨灵神",
	"李蓉蓉",
	"进阶李蓉蓉",
	"雷龙",
	"进阶雷龙",
	"怜星",
	"进阶怜星",
	"光明战神",
	"进阶光明战神",
	"执音",
	"进阶执音",
	"洛神",
	"进阶洛神",
	"赤炎战神",
	"进阶赤炎战神",
	"神僧",
	"进阶神僧",
	"青霞仙子",
	"进阶青霞仙子",
	"火龙骑士",
	"进阶火龙骑士",
	"杀阡陌",
	"进阶杀阡陌",
	"通臂猿猴",
	"进阶通臂猿猴",
	"白龙骑士",
	"进阶白龙骑士",
	"尉迟恭",
	"进阶尉迟恭",
	"蓝人龙",
	"进阶蓝人龙",
	"邀月",
	"进阶邀月",
	"太极神君",
	"进阶太极神君",
	"赵敏",
	"进阶赵敏",
	"大蛇丸",
	"进阶大蛇丸",
	"干柿鬼鲛",
	"进阶干柿鬼鲛",
	"佩恩",
	"进阶佩恩",
	"李洛克",
	"进阶李洛克",
	"小南",
	"进阶小南",
	"春野樱",
	"进阶春野樱",
	"宇智波带土",
	"进阶宇智波带土",
	"宇智波鼬",
	"进阶宇智波鼬",
	"宇智波佐助",
	"进阶宇智波佐助",
	"女仙",
	"进阶女仙",
	"剑魂",
	"进阶剑魂",
	"枪魂",
	"进阶枪魂",
	"龙魂仙女",
	"进阶龙魂仙女",
	"黑悟空",
	"进阶黑悟空",
	"孙行者",
	"进阶孙行者",
	"白衣剑客",
	"进阶白衣剑客",
	"莲女",
	"进阶莲女",
	"绿衣女神",
	"进阶绿衣女神",
	"五彩神女",
	"进阶五彩神女",
	"红衣仙女",
	"进阶红衣仙女",
	"葫芦小金刚",
	"进阶葫芦小金刚",
	"路飞",
	"进阶路飞",
	"六道带土",
	"进阶六道带土",
	"大筒木辉夜",
	"进阶大筒木辉夜",
	"鼬",
	"进阶鼬",
	"佐助",
	"进阶佐助",
	"小佐助",
	"进阶小佐助",
	"旗木卡卡西",
	"进阶旗木卡卡西",
	"鸣人",
	"进阶鸣人",
	"小鸣人",
	"进阶小鸣人",
	"带土",
	"进阶带土",
	"我爱罗",
	"进阶我爱罗",
	"六道斑",
	"进阶六道斑"
}
模型库2 = {
	"壬寅神虎",
	"进阶壬寅神虎",
	"甲辰神龙",
	"进阶甲辰神龙",
	"癸卯神兔",
	"进阶癸卯神兔",
	"癸卯神兔_睡梦",
	"进阶癸卯神兔_睡梦",
	"超级人参娃娃",
	"进阶超级人参娃娃",
	"超级六耳猕猴",
	"进阶超级六耳猕猴",
	"超级土地公公",
	"进阶超级土地公公",
	"超级大熊猫",
	"进阶超级大熊猫",
	"超级大象",
	"进阶超级大象",
	"超级大象使者",
	"超级大鹏",
	"进阶超级大鹏",
	"超级孔雀",
	"进阶超级孔雀",
	"超级小白龙",
	"进阶超级小白龙",
	"超级有熊",
	"进阶超级有熊",
	"超级泡泡",
	"进阶超级泡泡",
	"超级海豚",
	"进阶超级海豚",
	"超级灵狐",
	"进阶超级灵狐",
	"超级灵鹿",
	"进阶超级灵鹿",
	"超级猪小戒",
	"进阶超级猪小戒",
	"超级玉兔",
	"进阶超级玉兔",
	"超级白泽",
	"进阶超级白泽",
	"超级白泽使者",
	"超级神兔",
	"进阶超级神兔",
	"超级神柚",
	"进阶超级神柚",
	"超级神牛",
	"进阶超级神牛",
	"超级神狗",
	"进阶超级神狗",
	"超级神猪",
	"进阶超级神猪",
	"超级神猴",
	"进阶超级神猴",
	"超级神羊",
	"进阶超级神羊",
	"超级神虎",
	"进阶超级神虎",
	"超级神蛇",
	"进阶超级神蛇",
	"超级神马",
	"进阶超级神马",
	"超级神鸡",
	"进阶超级神鸡",
	"超级神鼠",
	"进阶超级神鼠",
	"超级神龙",
	"进阶超级神龙",
	"超级离火兽",
	"进阶超级离火兽",
	"超级筋斗云",
	"进阶超级筋斗云",
	"超级红孩儿",
	"进阶超级红孩儿",
	"超级腾蛇",
	"超级赤焰兽",
	"进阶超级赤焰兽",
	"超级金猴",
	"进阶超级金猴",
	"超级青鸾",
	"进阶超级青鸾",
	"飞天",
	"进阶飞天",
	"超级飞廉",
	"进阶超级飞廉",
	"超级麒麟",
	"进阶超级麒麟",
	"辛丑神牛",
	"进阶辛丑神牛",
	"鲲鹏",
	"进阶鲲鹏",
	"龙马",
	"食铁兽",
	"逍遥神牛",
	"兔乖乖",
	"神兽孙小圣",
	"仙兽翼龙",
	"神兽小龙人",
	"神兽雪精灵",
	"神兽时光叽",
	"神兽百灵羊",
	"齐天小圣",
	"泡泡灵仙·剑侠客",
	"泡泡灵仙·巫蛮儿",
	"泡泡灵仙·杀破狼",
	"泡泡灵仙·神天兵",
	"泡泡灵仙·羽灵神",
	"泡泡灵仙·飞燕女",
	"泡泡灵仙·骨精灵",
	"泡泡灵仙·龙太子",
	"恶魔泡泡",
	"恶魔泡泡(哭泣)",
	"恶魔泡泡(困惑)",
	"恶魔泡泡(奸笑)",
	"恶魔泡泡(白眼)",
	"草龟",
	"元宝龟",
	"冰龟",
	"冰火龟",
	"火云龟",
	"熔岩龟",
	"毒云龟",
	"毒花龟(夜)",
	"毒花龟(日)",
	"云龟",
	"岩龟",
	"岩冰龟",
	"沙虫",
	"草叶虫",
	"草叶魂虫",
	"竹笋虫",
	"天机虫",
	"火沙虫",
	"熔火虫",
	"月光虫",
	"月光金乌虫",
	"金乌虫",
	"金乌火虫",
	"金乌月光虫",
	"食魂虫(夜)",
	"食魂虫(日)",
	"火月蛙",
	"熔火蛙",
	"积水蛙",
	"积水鬼蛙",
	"望月蛙",
	"雪蛙",
	"雪月蛙",
	"月光雪蛙",
	"鬼蛙",
	"泡泡",
	"护卫",
	"树怪",
	"大海龟",
	"巨蛙",
	"章鱼",
	"海星",
	"狸",
	"沙狸",
	"强盗沙狸",
	"海狸",
	"纵火狸",
	"胖海狸",
	"强盗狸",
	"强盗鬼狸",
	"鬼狸",
	"鬼火狸",
	"雪狸",
	"野猪",
	"野猪x",
	"大蝙蝠",
	"海毛虫",
	"强盗",
	"强盗x",
	"山贼",
	"山贼x",
	"赌徒",
	"赌徒x",
	"狐狸精",
	"狐狸精x",
	"羊头怪",
	"羊头怪x",
	"花妖",
	"花妖x",
	"骷髅怪",
	"骷髅怪x",
	"蛤蟆精",
	"蛤蟆精x",
	"老虎",
	"老虎x",
	"黑熊",
	"黑熊x",
	"野鬼",
	"野鬼x",
	"虾兵",
	"虾兵x",
	"蟹将",
	"蟹将x",
	"牛妖",
	"牛妖x",
	"小龙女",
	"小龙女x",
	"狼",
	"狼x",
	"牛头",
	"牛头x",
	"马面",
	"马面x",
	"僵尸",
	"僵尸x",
	"龟丞相",
	"龟丞相x",
	"蜘蛛精",
	"蜘蛛精x",
	"兔子怪",
	"兔子怪x",
	"黑熊精",
	"黑熊精x",
	"黑山老妖",
	"黑山老妖x",
	"进阶黑山老妖",
	"蝴蝶仙子",
	"蝴蝶仙子x",
	"进阶蝴蝶仙子",
	"雷鸟人",
	"雷鸟人x",
	"进阶雷鸟人",
	"白熊",
	"白熊x",
	"进阶白熊",
	"古代瑞兽",
	"古代瑞兽x",
	"进阶古代瑞兽",
	"天兵",
	"天兵x",
	"进阶天兵",
	"风伯",
	"风伯x",
	"进阶风伯",
	"地狱战神",
	"地狱战神x",
	"进阶地狱战神",
	"阿宝",
	"进阶阿宝",
	"花铃",
	"进阶花铃",
	"天将",
	"天将x",
	"进阶天将",
	"蛟龙",
	"蛟龙x",
	"进阶蛟龙",
	"凤凰",
	"凤凰x",
	"进阶凤凰",
	"蚌精",
	"进阶蚌精",
	"鲛人",
	"进阶鲛人",
	"碧水夜叉",
	"进阶碧水夜叉",
	"雨师",
	"雨师x",
	"进阶雨师",
	"独角鬼王",
	"进阶独角鬼王",
	"月影仙",
	"进阶月影仙",
	"龙鲤",
	"进阶龙鲤",
	"炼丹童子",
	"进阶炼丹童子",
	"星灵仙子",
	"星灵仙子x",
	"进阶星灵仙子",
	"巡游天神",
	"巡游天神x",
	"进阶巡游天神",
	"犀牛将军人形",
	"进阶犀牛将军人形",
	"犀牛将军兽形",
	"进阶犀牛将军兽形",
	"锦毛貂精",
	"进阶锦毛貂精",
	"千年蛇魅",
	"进阶千年蛇魅",
	"芙蓉仙子",
	"芙蓉仙子x",
	"进阶芙蓉仙子",
	"如意仙子",
	"如意仙子x",
	"进阶如意仙子",
	"野猪精",
	"进阶野猪精",
	"百足将军",
	"进阶百足将军",
	"鼠先锋",
	"进阶鼠先锋",
	"泪妖",
	"进阶泪妖",
	"镜妖",
	"进阶镜妖",
	"日游神",
	"进阶日游神",
	"金翼",
	"进阶金翼",
	"吸血鬼",
	"吸血鬼x",
	"进阶吸血鬼",
	"幽灵",
	"幽灵x",
	"进阶幽灵",
	"灵符女娲",
	"进阶灵符女娲",
	"律法女娲",
	"进阶律法女娲",
	"阴阳伞",
	"进阶阴阳伞",
	"云游火",
	"进阶云游火",
	"玄珠灵仙",
	"进阶玄珠灵仙",
	"巨石守卫(昼)",
	"进阶巨石守卫(昼)",
	"狐不归",
	"进阶狐不归",
	"虬龙",
	"进阶虬龙",
	"五行山神(金)",
	"进阶五行山神(金)",
	"五行山神(木)",
	"进阶五行山神(木)",
	"五行山神(水)",
	"进阶五行山神(水)",
	"五行山神(火)",
	"进阶五行山神(火)",
	"五行山神(土)",
	"进阶五行山神(土)",
	"鬼将",
	"鬼将x",
	"进阶鬼将",
	"净瓶女娲",
	"进阶净瓶女娲",
	"幽萤娃娃",
	"进阶幽萤娃娃",
	"画魂",
	"进阶画魂",
	"巨石守卫(夜)",
	"进阶巨石守卫(夜)",
	"涂山瞳",
	"进阶涂山瞳",
	"大力金刚",
	"大力金刚x",
	"进阶大力金刚",
	"夜罗刹",
	"夜罗刹x",
	"进阶夜罗刹",
	"雾中仙",
	"雾中仙x",
	"进阶雾中仙",
	"灵鹤",
	"灵鹤x",
	"进阶灵鹤",
	"炎魔神",
	"炎魔神x",
	"进阶炎魔神",
	"噬天虎",
	"噬天虎x",
	"进阶噬天虎",
	"金铙僧",
	"进阶金铙僧",
	"月魅",
	"进阶月魅",
	"夜游神",
	"进阶夜游神",
	"幻姬",
	"进阶幻姬",
	"琴仙",
	"进阶琴仙",
	"踏云兽",
	"进阶踏云兽",
	"红萼仙子",
	"进阶红萼仙子",
	"葫芦宝贝",
	"进阶葫芦宝贝",
	"猫灵人形",
	"进阶猫灵人形",
	"猫灵兽形",
	"进阶猫灵兽形",
	"狂豹人形",
	"进阶狂豹人形",
	"黑白狂豹人形",
	"狂豹兽形",
	"进阶狂豹兽形",
	"蝎子精",
	"进阶蝎子精",
	"龙龟",
	"进阶龙龟",
	"机关人",
	"进阶机关人",
	"机关兽",
	"进阶机关兽",
	"机关鸟",
	"进阶机关鸟",
	"连弩车",
	"进阶连弩车",
	"巴蛇",
	"进阶巴蛇",
	"长眉灵猴",
	"进阶长眉灵猴",
	"巨力神猿",
	"进阶巨力神猿",
	"修罗傀儡鬼",
	"进阶修罗傀儡鬼",
	"藤蔓妖花",
	"进阶藤蔓妖花",
	"无常鬼差(白)",
	"进阶无常鬼差(白)",
	"无常鬼差(黑)",
	"进阶无常鬼差(黑)",
	"执音",
	"进阶执音",
	"有苏鸩",
	"进阶有苏鸩",
	"司辰侍者(未来)",
	"进阶司辰侍者(未来)",
	"司辰侍者(过去)",
	"进阶司辰侍者(过去)",
	"混沌兽",
	"进阶混沌兽",
	"蜃气妖",
	"进阶蜃气妖",
	"修罗傀儡妖",
	"进阶修罗傀儡妖",
	"金身罗汉",
	"进阶金身罗汉",
	"曼珠沙华",
	"进阶曼珠沙华",
	"毗舍童子",
	"进阶毗舍童子",
	"暗黑毗舍童子",
	"真陀护法",
	"进阶真陀护法",
	"灵灯侍者",
	"进阶灵灯侍者",
	"涂山雪",
	"进阶涂山雪",
	"魔化毗舍童子",
	"进阶魔化毗舍童子",
	"雷龙",
	"进阶雷龙",
	"觉醒涂山雪",
	"进阶觉醒涂山雪",
	"司风",
	"进阶司风",
	"司雪",
	"进阶司雪",
	"司雨",
	"进阶司雨",
	"自在心猿",
	"进阶自在心猿",
	"持国巡守",
	"进阶持国巡守",
	"增长巡守",
	"进阶增长巡守",
	"般若天女",
	"进阶般若天女",
	"广目巡守",
	"进阶广目巡守",
	"多闻巡守",
	"进阶多闻巡守",
	"妙华天女",
	"进阶妙华天女",
	"谛听",
	"进阶谛听",
	"暗黑谛听",
	"长乐灵仙",
	"进阶长乐灵仙",
	"沙暴",
	"进阶沙暴",
	"牛虱",
	"燧明兽",
	"九色鹿",
	"雪人",
	"哮天犬",
	"进阶哮天犬",
	"熊猫武神",
	"狐狸",
	"小丫丫",
	"进阶小丫丫",
	"小仙女",
	"进阶小仙女",
	"小毛头",
	"进阶小毛头",
	"小神灵",
	"进阶小神灵",
	"小精灵",
	"进阶小精灵",
	"小魔头",
	"进阶小魔头",
	"善财童子鼓",
	"善财童子玉",
	"小彩蝶",
	"小蓝娥",
	"小浪鼓",
	"小绅士",
	"小圣斗士",
	"小兔兔",
	"小熊熊",
	"小DJ",
	"小卷发",
	"小羊角",
	"小战神",
	"小神女",
	"偃甲(女0)",
	"偃甲(女1)",
	"偃甲(女2)",
	"偃甲(男0)",
	"偃甲(男1)",
	"偃甲(男2)",
	"琴瑟仙女",
	"二大王",
	"红孩儿",
	"白骨精",
	"新猪八戒",
	"紫霞",
	"新孙悟空",
	"小欣",
	"神武雨师",
	"萼华仙子",
	"蚩尤武魂",
	"神武风伯",
	"幽灵虎",
	"龙虾骑士",
	"战神罗成",
	"死亡骑士",
	"贪狼",
	"小肥羊",
	"月影兔",
	"玄武",
	"金钱龟",
	"金麟鹿",
	"吉祥",
	"嵩鼠",
	"龙须豹",
	"杨二郎",
	"小雪人",
	"团团",
	"龙仙",
	"武罗仙子",
	"暗黑龙",
	"剑灵双子",
	"太极捶童子",
	"暗雷豹",
	"黑灵猫",
	"红衣战锤使",
	"美猴王",
	"火熔石",
	"三尾火狐",
	"骏天马",
	"鲛人鱼",
	"狗头人",
	"巨灵狼",
	"黑翼弓使",
	"无名上仙",
	"光辉女神",
	"四翼上仙",
	"大象精",
	"四臂魔神",
	"老鹰精",
	"氪金大佬",
	"超级三眼娃",
	"太极真君",
	"进阶太极真君",
	"托塔娃",
	"巨斧猛男",
	"齐天大圣",
	"酷炫佬",
	"酷炫老逼登",
	"风火轮器灵",
	"月宫仙子",
	"夜莺",
	"蓝凤凰",
	"熊猫大侠",
	"白無常",
	"拽王",
	"萌狗",
	"小红孩儿",
	"月仙",
	"狮仙",
	"剑仙",
	"判官",
	"龙羽",
	"罗汉",
	"龙王",
	"天师",
	"战将",
	"狂狮",
	"佛子",
	"葫仙",
	"法僧",
	"金衣仙",
	"龙剑士",
	"龙剑女",
	"水龙",
	"画仙",
	"天帝",
	"镇元",
	"鬼君",
	"鹿君",
	"火女",
	"福禄仙",
	"天后",
	"太极老君",
	"天兵统领",
	"阎王爷",
	"赵云",
	"紫霞仙子",
	"阿朱",
	"白子画",
	"貂蝉",
	"凤九",
	"关羽",
	"Q版魔化毗舍童子",
	"花无缺",
	"剑圣",
	"巨灵神",
	"李蓉蓉",
	"怜星",
	"光明战神",
	"洛神",
	"赤炎战神",
	"神僧",
	"青霞仙子",
	"火龙骑士",
	"杀阡陌",
	"通臂猿猴",
	"白龙骑士",
	"尉迟恭",
	"蓝人龙",
	"邀月",
	"太极神君",
	"赵敏",
	"大蛇丸",
	"干柿鬼鲛",
	"佩恩",
	"李洛克",
	"小南",
	"春野樱",
	"宇智波带土",
	"宇智波鼬",
	"宇智波佐助",
	"女仙",
	"斧魂",
	"剑魂",
	"枪魂",
	"月皇",
	"鬼妃",
	"月灵",
	"琴鹤",
	"晶怪",
	"魂女猫",
	"金凤凰",
	"砍刀猴",
	"金长毛猪",
	"蓝衣剑魂",
	"鸟妖仙",
	"龙魂仙女",
	"黑悟空",
	"孙行者",
	"白衣剑客",
	"猫女",
	"莲女",
	"绿衣女神",
	"五彩神女",
	"红衣仙女",
	"葫芦小金刚",
	"路飞",
	"部落勇士",
	"部落酋长",
	"幼狮",
	"嘲风",
	"吕布",
	"魔化吕布",
	"神射手",
	"黑猫警长",
	"惊奇队长",
	"灭霸",
	"绿巨人",
	"钢铁侠",
	"雷神托尔",
	"智慧女神",
	"紫焰妖姬",
	"白素贞",
	"彩蝶依依",
	"春岚蔷薇",
	"剑姬",
	"小青",
	"妖星",
	"女飞贼",
	"白娘子",
	"貂裘红衣",
	"小魔女",
	"小狐狸",
	"蓝仙女",
	"女捕头",
	"女狐妖",
	"三尾妖狐",
	"蝠女",
	"男狐妖",
	"婚纱女",
	"红娘子",
	"蝶妖",
	"鬼魅"
}

计算阶段属性 = function(lv)
	local aa = {
		速度 = qz((lv * 6 + 20) * 1500 * 0.001 * 0.5),
		伤害 = qz(lv * 1500 * 3.85 * 0.001 + (lv * 6 + 20) * 1.5),
		防御 = qz(lv * 1500 * 2.535 * 0.001 + (lv * 5 + 20) * 1.5 * 1.33),
		气血 = qz(lv * 6000 * 0.001 + (lv * 6 + 20) * 6 * 1.5) * 2,
		魔法 = qz(lv * 4000 * 0.002 + (lv * 6 + 20) * 3 * 1.5) * 2,
		法伤 = qz(lv * 4000 * 0.0003 * 1.5 + lv * 1.4 + (lv * 6.5 + 20) * 0.7 * 1.5),
		法防 = qz(lv * 4000 * 0.0003 + lv * 1.4 + (lv * 6 + 20) * 0.7 * 1.5),
		躲避 = qz((lv * 6 + 20) * 1800 * 0.001),
		修炼 = 取人物修炼等级上限1(lv)
	}

	return aa
end

阶段属性 = {}

for i = 1, 201 do
	阶段属性[i - 1] = 计算阶段属性(i + 4)
end

function 战斗准备类:初始化()
	self.战斗盒子 = {}
end

function 战斗准备类:创建玩家战斗(玩家id, 序号, 任务id, 地图)
	if 玩家数据[任务id] == nil or 玩家数据[任务id] ~= nil and 玩家数据[任务id].角色.数据.战斗开关 then
		常规提示(玩家id, "#Y/对方正在战斗中......")

		return
	end

	if 玩家id == 任务id then
		常规提示(玩家id, "#Y/自己打自己?你是不是打傻了?......")

		return
	end

	if 玩家数据[玩家id].队伍 ~= 0 and 玩家数据[玩家id].队长 == false or 玩家数据[任务id].队伍 ~= 0 and 玩家数据[任务id].队长 == false then
		常规提示(玩家id, "#Y/只有队长才能触发战斗!......")

		return
	end

	if 序号 == 200006 and 玩家数据[玩家id].角色.数据.帮派数据.编号 == 玩家数据[任务id].角色.数据.帮派数据.编号 then
		常规提示(玩家id, "#Y/同一帮派的玩家之间无法触发战斗！")

		return
	end

	if 序号 == 200004 and 玩家数据[玩家id].角色.数据.ip == 玩家数据[任务id].角色.数据.ip then
		常规提示(玩家id, "#Y/比武场不能自己和自己刷分")

		return
	elseif 序号 == 200004 and 玩家数据[玩家id].角色.数据.账号 == 玩家数据[任务id].角色.数据.账号 then
		常规提示(玩家id, "#Y/比武场不能自己和自己刷分")

		return
	end

	self.临时id = 玩家id .. os.time() .. 取随机数(1, 999999)
	self.临时id = self.临时id + 0

	if 玩家数据[玩家id].队伍 == 0 then
		玩家数据[玩家id].战斗 = self.临时id
	else
		for n = 1, #队伍数据[玩家数据[玩家id].队伍].成员数据 do
			if 队伍处理类:取是否助战(玩家数据[玩家id].队伍, n) == 0 then
				玩家数据[队伍数据[玩家数据[玩家id].队伍].成员数据[n]].战斗 = self.临时id
			end
		end
	end

	if 玩家数据[任务id].队伍 == 0 then
		玩家数据[任务id].战斗 = self.临时id
	else
		for n = 1, #队伍数据[玩家数据[任务id].队伍].成员数据 do
			if 队伍处理类:取是否助战(玩家数据[任务id].队伍, n) == 0 then
				玩家数据[队伍数据[玩家数据[任务id].队伍].成员数据[n]].战斗 = self.临时id
			end
		end
	end

	地图处理类:设置战斗开关(玩家id, true)

	if 序号 == 200001 or 序号 == 200002 or 序号 == 200003 or 序号 == 200004 or 序号 == 200005 or 序号 == 200006 or 序号 == 200007 or 序号 == 200008 then
		地图处理类:设置战斗开关(任务id, true)

		玩家数据[任务id].角色.数据.气血 = 玩家数据[任务id].角色.数据.最大气血
		玩家数据[任务id].角色.数据.魔法 = 玩家数据[任务id].角色.数据.最大魔法
		玩家数据[玩家id].角色.数据.气血 = 玩家数据[玩家id].角色.数据.最大气血
		玩家数据[玩家id].角色.数据.魔法 = 玩家数据[玩家id].角色.数据.最大魔法

		if 序号 == 200003 or 序号 == 200004 or 序号 == 200005 or 序号 == 200006 then
			常规提示(任务id, "#Y你进入了由#R" .. 玩家数据[玩家id].角色.数据.名称 .. "#Y发起的战斗中")
		elseif 序号 == 200007 then
			常规提示(任务id, "#Y你进入了由#R" .. 玩家数据[玩家id].角色.数据.名称 .. "#Y发起的战斗中,战斗失败将会受到失败死亡惩罚！")
		elseif 序号 == 200008 then
			常规提示(任务id, "#Y你进入了由#R" .. 玩家数据[玩家id].角色.数据.名称 .. "#Y发起的战斗中,战斗失败将会受到三倍失败死亡惩罚！")
		end
	end

	self.战斗盒子[self.临时id] = 战斗处理类.创建()

	self.战斗盒子[self.临时id]:进入战斗(玩家id, 序号, 任务id, 地图)
end

function 战斗准备类:创建战斗(玩家id, 序号, 任务id, 地图, 假人属性)
	local 临时id = 取随机数(999999, 9999999) .. "_" .. 玩家id .. "_" .. os.time() .. "_" .. 取随机数(1, 999999)
	玩家数据[玩家id].战斗 = 临时id

	if 玩家数据[玩家id].队伍 == 0 then
		玩家数据[玩家id].角色.数据.战斗开关 = true

		地图处理类:设置战斗开关(玩家id, true)
	else
		for n = 1, #队伍数据[玩家数据[玩家id].队伍].成员数据 do
			if 玩家数据[队伍数据[玩家数据[玩家id].队伍].成员数据[n]].队伍 == 玩家数据[玩家id].队伍 and 队伍处理类:取是否助战(玩家数据[玩家id].队伍, n) == 0 then
				玩家数据[队伍数据[玩家数据[玩家id].队伍].成员数据[n]].战斗 = 临时id
				玩家数据[队伍数据[玩家数据[玩家id].队伍].成员数据[n]].角色.数据.战斗开关 = true

				地图处理类:设置战斗开关(队伍数据[玩家数据[玩家id].队伍].成员数据[n], true)
			end
		end
	end

	self.战斗盒子[临时id] = 战斗处理类.创建()

	if 序号 == 100001 or 序号 == 100007 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, 地图)
	elseif 序号 == 10086 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取宠修战斗信息(任务id, 玩家id))
	elseif 序号 == 100002 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取宝图强盗信息(任务id, 玩家id))
	elseif 序号 == 100003 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取宝图遇怪信息(任务id, 玩家id))
	elseif 序号 == 100004 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取封妖任务信息(任务id, 玩家id))
	elseif 序号 == 100005 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取幼儿园信息(任务id, 玩家id))
	elseif 序号 == 100006 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取科举闯关信息(任务id, 玩家id))
	elseif 序号 == 100008 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取捉鬼任务信息(任务id, 玩家id))
	elseif 序号 == 100008.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取鬼王任务信息(任务id, 玩家id))
	elseif 序号 == 100008.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取梦靥夜叉(任务id, 玩家id))
	elseif 序号 == 100009 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取星宿任务信息(任务id, 玩家id))
	elseif 序号 == 100010 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妖魔鬼怪信息(任务id, 玩家id))
	elseif 序号 == 100011 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派闯关信息(任务id, 玩家id))
	elseif 序号 == 100012 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取游泳水妖信息(任务id, 玩家id))
	elseif 序号 == 100013 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取官职流氓信息(任务id, 玩家id))
	elseif 序号 == 100014 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取官职巡逻信息(任务id, 玩家id))
	elseif 序号 == 100015 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派巡逻信息(任务id, 玩家id))
	elseif 序号 == 100016 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派示威信息(任务id, 玩家id))
	elseif 序号 == 100017 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派支援信息(任务id, 玩家id))
	elseif 序号 == 100018 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派乾坤袋信息(任务id, 玩家id))
	elseif 序号 == 100019 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取迷宫小怪信息(任务id, 玩家id))
	elseif 序号 == 100020 then
		if 任务数据[任务id].模型 == "炎魔神" then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妖王炎魔神(任务id, 玩家id))
		elseif 任务数据[任务id].模型 == "鬼将" then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妖王鬼将(任务id, 玩家id))
		elseif 任务数据[任务id].模型 == "净瓶女娲" then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妖王净瓶女娲(任务id, 玩家id))
		end
	elseif 序号 == 100021 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取江湖大盗信息(任务id, 玩家id))
	elseif 序号 == 100022 then
		if 任务数据[任务id].分类 == 1 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取毛贼信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 2 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取销赃贼信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 3 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取宝贼信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 4 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取盗贼首领信息(任务id, 玩家id))
		end
	elseif 序号 == 100023 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取皇宫贼王信息(任务id, 玩家id))
	elseif 序号 == 100024 then
		if 任务数据[任务id].等级 == 150 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取150级世界BOSS信息(任务id, 玩家id))
		elseif 任务数据[任务id].等级 == 150 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取150级世界BOSS信息(任务id, 玩家id))
		elseif 任务数据[任务id].等级 == 150 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取150级世界BOSS信息(任务id, 玩家id))
		end
	elseif 序号 == 100025 then
		local 随机序列 = 取随机数(1, #任务数据[任务id].完成)
		local 战斗序列 = 任务数据[任务id].完成[随机序列]
		任务数据[任务id].战斗序列 = 随机序列

		if 战斗序列 == 1 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息1(任务id, 玩家id))
		elseif 战斗序列 == 2 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息2(任务id, 玩家id))
		elseif 战斗序列 == 3 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息3(任务id, 玩家id))
		elseif 战斗序列 == 4 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息4(任务id, 玩家id))
		elseif 战斗序列 == 5 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息5(任务id, 玩家id))
		elseif 战斗序列 == 6 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取镖王信息6(任务id, 玩家id))
		end
	elseif 序号 == 34479.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取门派入侵(任务id, 玩家id))
	elseif 序号 == 34479.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取突厥精英(任务id, 玩家id))
	elseif 序号 == 34479.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取突厥探子(任务id, 玩家id))
	elseif 序号 == 34470.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取天蓬娶亲1(任务id, 玩家id))
	elseif 序号 == 34470.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取天蓬娶亲2(任务id, 玩家id))
	elseif 序号 == 34470.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取天蓬娶亲3(任务id, 玩家id))
	elseif 序号 == 34470.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取天蓬娶亲4(任务id, 玩家id))
	elseif 序号 == 34471.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取白龙闹海1(任务id, 玩家id))
	elseif 序号 == 34471.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取白龙闹海2(任务id, 玩家id))
	elseif 序号 == 34471.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取白龙闹海3(任务id, 玩家id))
	elseif 序号 == 34471.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取白龙闹海4(任务id, 玩家id))
	elseif 序号 == 34480.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物1(任务id, 玩家id))
	elseif 序号 == 34480.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物2(任务id, 玩家id))
	elseif 序号 == 34480.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物3(任务id, 玩家id))
	elseif 序号 == 34480.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物4(任务id, 玩家id))
	elseif 序号 == 34480.5 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物5(任务id, 玩家id))
	elseif 序号 == 34480.6 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物6(任务id, 玩家id))
	elseif 序号 == 34480.7 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物7(任务id, 玩家id))
	elseif 序号 == 34480.8 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物8(任务id, 玩家id))
	elseif 序号 == 34480.9 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取对应宠物9(任务id, 玩家id))
	elseif 序号 == 34481.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙1(任务id, 玩家id))
	elseif 序号 == 34481.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙2(任务id, 玩家id))
	elseif 序号 == 34481.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙3(任务id, 玩家id))
	elseif 序号 == 34481.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙4(任务id, 玩家id))
	elseif 序号 == 34481.5 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙5(任务id, 玩家id))
	elseif 序号 == 34481.6 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙6(任务id, 玩家id))
	elseif 序号 == 34481.7 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙7(任务id, 玩家id))
	elseif 序号 == 34481.8 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙8(任务id, 玩家id))
	elseif 序号 == 34481.9 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙9(任务id, 玩家id))
	elseif 序号 == 34481.11 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙11(任务id, 玩家id))
	elseif 序号 == 34481.12 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙12(任务id, 玩家id))
	elseif 序号 == 34481.13 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取含冤小白龙13(任务id, 玩家id))
	elseif 序号 == 34482.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取女娲神迹1(任务id, 玩家id))
	elseif 序号 == 34482.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空1(任务id, 玩家id))
	elseif 序号 == 34482.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空2(任务id, 玩家id))
	elseif 序号 == 34482.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空3(任务id, 玩家id))
	elseif 序号 == 34482.5 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空4(任务id, 玩家id))
	elseif 序号 == 34482.6 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空5(任务id, 玩家id))
	elseif 序号 == 34482.7 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空6(任务id, 玩家id))
	elseif 序号 == 34482.8 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空7(任务id, 玩家id))
	elseif 序号 == 34482.9 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空8(任务id, 玩家id))
	elseif 序号 == 34482.11 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空9(任务id, 玩家id))
	elseif 序号 == 34482.12 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取八戒悟空10(任务id, 玩家id))
	elseif 序号 == 134480.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山除虫(任务id, 玩家id))
	elseif 序号 == 134480.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山打扫(任务id, 玩家id))
	elseif 序号 == 134480.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山鬼魂(任务id, 玩家id))
	elseif 序号 == 134480.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山恶虎(任务id, 玩家id))
	elseif 序号 == 134480.5 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山鬼鬼祟祟黑熊精(任务id, 玩家id))
	elseif 序号 == 134480.6 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山熊熊烈火(任务id, 玩家id))
	elseif 序号 == 134480.7 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山黑汉(任务id, 玩家id))
	elseif 序号 == 134480.8 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山小妖(任务id, 玩家id))
	elseif 序号 == 134480.9 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黑风山黑熊精(任务id, 玩家id))
	elseif 序号 == 134481.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫奢比尸(任务id, 玩家id))
	elseif 序号 == 134481.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫翕兹(任务id, 玩家id))
	elseif 序号 == 134481.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫天吴(任务id, 玩家id))
	elseif 序号 == 134481.4 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫强良(任务id, 玩家id))
	elseif 序号 == 134481.5 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫烛九阴(任务id, 玩家id))
	elseif 序号 == 134481.6 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫后土(任务id, 玩家id))
	elseif 序号 == 134481.7 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫帝江(任务id, 玩家id))
	elseif 序号 == 134481.8 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫蓐收(任务id, 玩家id))
	elseif 序号 == 134481.9 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫句芒(任务id, 玩家id))
	elseif 序号 == 134481.11 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫玄冥(任务id, 玩家id))
	elseif 序号 == 134481.12 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫共工(任务id, 玩家id))
	elseif 序号 == 134481.13 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取十二祖巫祝融(任务id, 玩家id))
	elseif 序号 == 100026 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取三界悬赏令信息(任务id, 玩家id))
	elseif 序号 == 100027 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取知了王信息(任务id, 玩家id))
	elseif 序号 == 100028 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取副本芭蕉妖怪信息(任务id, 玩家id))
	elseif 序号 == 100029 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取副本三妖信息(任务id, 玩家id))
	elseif 序号 == 100030 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取副本鬼祟小怪信息(任务id, 玩家id))
	elseif 序号 == 100031 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取副本国王信息(任务id, 玩家id))
	elseif 序号 == 100032 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天庭叛逆(任务id, 玩家id))
	elseif 序号 == 100033 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:捣乱的水果(任务id, 玩家id))
	elseif 序号 == 100034 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取青龙巡逻信息(任务id, 玩家id))
	elseif 序号 == 100035 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取玄武巡逻信息(任务id, 玩家id))
	elseif 序号 == 100037 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取地煞信息(任务id, 玩家id))
	elseif 序号 == 100040 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大力神灵信息(任务id, 玩家id))
	elseif 序号 == 100041 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妖魔亲信信息(任务id, 玩家id))
	elseif 序号 == 100042 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取蜃妖元神信息(任务id, 玩家id))
	elseif 序号 == 100043 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取周猎户信息(任务id, 玩家id))
	elseif 序号 == 100044 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取法宝战斗信息(任务id, 玩家id))
	elseif 序号 == 100045 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取法宝内丹战斗信息(任务id, 玩家id))
	elseif 序号 == 100046 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取横行霸道的土匪战斗信息(任务id, 玩家id))
	elseif 序号 == 100047 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升心魔战斗信息(任务id, 玩家id))
	elseif 序号 == 100048 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升小妖战斗信息(任务id, 玩家id))
	elseif 序号 == 100049 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升小宝箱战斗信息(任务id, 玩家id))
	elseif 序号 == 100050 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升阵法1战斗信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100051 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升阵法2战斗信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100052 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升阵法3战斗信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100053 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升阵法4战斗信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100054 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取飞升阵法5战斗信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100055 then
		if 生死劫数据[玩家id] == 1 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息1(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 2 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息2(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 3 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息3(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 4 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息4(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 5 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息5(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 6 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息6(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 7 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息7(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 8 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息8(任务id, 玩家id))
		elseif 生死劫数据[玩家id] == 9 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取生死劫信息9(任务id, 玩家id))
		end
	elseif 序号 == 100056 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取天罡星信息(任务id, 玩家id))
	elseif 序号 == 100060 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取新服福利BOSS信息(任务id, 玩家id))
	elseif 序号 == 100066 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取车迟斗法贡品信息(任务id, 玩家id))
	elseif 序号 == 100067 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取车迟斗法三清信息(任务id, 玩家id))
	elseif 序号 == 100068 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取车迟斗法求雨信息(任务id, 玩家id))
	elseif 序号 == 100069 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取车迟斗法不动信息(任务id, 玩家id))
	elseif 序号 == 100070 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取车迟斗法妖怪信息(任务id, 玩家id))
	elseif 序号 == 100084 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取散财童子信息(任务id, 玩家id))
	elseif 序号 == 100085 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取神秘妖怪信息(任务id, 玩家id))
	elseif 序号 == 100086 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妄空曰天冷信息(任务id, 玩家id))
	elseif 序号 == 100087 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妄空曰天冷信息2(任务id, 玩家id))
	elseif 序号 == 100088 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取渡劫师傅信息(任务id, 玩家id))
	elseif 序号 == 100089 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取妄空曰天冷信息2(任务id, 玩家id))
	elseif 序号 == 100090 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取蚩尤幻影信息(任务id, 玩家id))
	elseif 序号 == 100097 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取马超信息(任务id, 玩家id))
	elseif 序号 == 100098 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取黄忠信息(任务id, 玩家id))
	elseif 序号 == 100099 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取张飞信息(任务id, 玩家id))
	elseif 序号 == 100100 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取关羽信息(任务id, 玩家id))
	elseif 序号 == 100101 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取赵云信息(任务id, 玩家id))
	elseif 序号 == 100105 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取福利宝箱怪(任务id, 玩家id))
	elseif 序号 == 100106 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取倾国倾城信息(任务id, 玩家id))
	elseif 序号 == 100107 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取美食专家信息(任务id, 玩家id))
	elseif 序号 == 100108 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天塔信息(任务id, 玩家id, 假人属性))
	elseif 序号 == 100109 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取贼王的线索信息(任务id, 玩家id))
	elseif 序号 == 100110 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取貔貅的羁绊信息(任务id, 玩家id))
	elseif 序号 == 100112 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆桃木虫信息(任务id, 玩家id))
	elseif 序号 == 100113 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆泼猴信息(任务id, 玩家id))
	elseif 序号 == 100114 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆翼虎必死信息(任务id, 玩家id))
	elseif 序号 == 100115 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆蝰蛇必死信息(任务id, 玩家id))
	elseif 序号 == 100116 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆翼虎信息(任务id, 玩家id))
	elseif 序号 == 100117 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆蝰蛇信息(任务id, 玩家id))
	elseif 序号 == 100118 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆魑魅魍魉信息(任务id, 玩家id))
	elseif 序号 == 100118.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆巡山小妖信息(任务id, 玩家id))
	elseif 序号 == 100118.2 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆上古妖兽头领信息(任务id, 玩家id))
	elseif 序号 == 100118.3 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆妖将军信息(任务id, 玩家id))
	elseif 序号 == 100119 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取水陆毒虫信息(任务id, 玩家id))
	elseif 序号 == 100120 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取宝图强盗信息(任务id, 玩家id))
	elseif 序号 == 100122 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取捣乱的年兽信息(任务id, 玩家id))
	elseif 序号 == 100123 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取年兽王信息(任务id, 玩家id))
	elseif 序号 == 100124 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取怨灵幻影信息(任务id, 玩家id))
	elseif 序号 == 100125 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取灵感分身信息(任务id, 玩家id))
	elseif 序号 == 100126 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天河妖信息(任务id, 玩家id))
	elseif 序号 == 100127 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天散财童子信息(任务id, 玩家id))
	elseif 序号 == 100128 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天黑熊精信息(任务id, 玩家id))
	elseif 序号 == 100129 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天五色竹条信息(任务id, 玩家id))
	elseif 序号 == 100130 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天金鱼将军1信息(任务id, 玩家id))
	elseif 序号 == 100131 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天金鱼将军2信息(任务id, 玩家id))
	elseif 序号 == 100132 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天金鱼将军3信息(任务id, 玩家id))
	elseif 序号 == 100133 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天金鱼将军4信息(任务id, 玩家id))
	elseif 序号 == 100134 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天金鱼将军5信息(任务id, 玩家id))
	elseif 序号 == 100135 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取通天灵感大王信息(任务id, 玩家id))
	elseif 序号 == 110000 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:木桩伤害测试(任务id, 玩家id, 假人属性))
	elseif 序号 == 110001 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取剑会天下属性(假人属性))
	elseif 序号 == 110002 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:桃园蚩尤(任务id, 玩家id))
	elseif 序号 == 110003 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:桃园野猪(任务id, 玩家id))
	elseif 序号 == 110004 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:商人的鬼魂(任务id, 玩家id))
	elseif 序号 == 110005 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:妖风战斗(任务id, 玩家id))
	elseif 序号 == 110006 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:白鹿精(任务id, 玩家id))
	elseif 序号 == 110007 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:酒肉和尚假(任务id, 玩家id))
	elseif 序号 == 110008 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:执法天兵(任务id, 玩家id))
	elseif 序号 == 110009 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:白琉璃(任务id, 玩家id))
	elseif 序号 == 110010 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:酒肉和尚真(任务id, 玩家id))
	elseif 序号 == 110011 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:幽冥鬼(任务id, 玩家id))
	elseif 序号 == 110012 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:蟹将军(任务id, 玩家id))
	elseif 序号 == 110013 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:假刘洪(任务id, 玩家id))
	elseif 序号 == 110014 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:真刘洪(任务id, 玩家id))
	elseif 序号 == 110015 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天兵飞剑(任务id, 玩家id))
	elseif 序号 == 110016 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:日常商人鬼魂(任务id, 玩家id))
	elseif 序号 == 110034 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:蚩尤大战(任务id, 玩家id))
	elseif 序号 == 110035 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:妖风战斗日常(任务id, 玩家id))
	elseif 序号 == 110135 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:刻晴全服奖励(任务id, 玩家id))
	elseif 序号 == 110036 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:白鹿精日常(任务id, 玩家id))
	elseif 序号 == 110038 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:押镖遇怪(任务id, 玩家id))
	elseif 序号 == 100147 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹抢水信息(任务id, 玩家id))
	elseif 序号 == 100148 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹除虫信息(任务id, 玩家id))
	elseif 序号 == 100149 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹仙女信息(任务id, 玩家id))
	elseif 序号 == 100150 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹造酒信息(任务id, 玩家id))
	elseif 序号 == 100151 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹运水信息(任务id, 玩家id))
	elseif 序号 == 100152 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹烧火信息(任务id, 玩家id))
	elseif 序号 == 100153 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹盘槽信息(任务id, 玩家id))
	elseif 序号 == 100154 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹天兵信息(任务id, 玩家id))
	elseif 序号 == 100155 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹天将信息(任务id, 玩家id))
	elseif 序号 == 100156 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹二郎神信息(任务id, 玩家id))
	elseif 序号 == 100156.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹惠岸行者信息(任务id, 玩家id))
	elseif 序号 == 100157 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取大闹上古雷神信息(任务id, 玩家id))
	elseif 序号 == 100214 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:齐天黑无常(任务id, 玩家id))
	elseif 序号 == 100214.1 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:齐天白无常(任务id, 玩家id))
	elseif 序号 == 100215 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:齐天阎王(任务id, 玩家id))
	elseif 序号 == 100216 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:齐天天王(任务id, 玩家id))
	elseif 序号 == 100217 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:齐天盗马贼(任务id, 玩家id))
	elseif 序号 == 100218 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大闹百万天兵(任务id, 玩家id))
	elseif 序号 == 100219 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大闹巨灵神(任务id, 玩家id))
	elseif 序号 == 100220 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大闹镇塔之神(任务id, 玩家id))
	elseif 序号 == 100221 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取幼儿园信息1(任务id, 玩家id))
	elseif 序号 == 100222 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:首席争霸(任务id, 玩家id, 假人属性))
	elseif 序号 == 100223 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:酒肉日常(任务id, 玩家id))
	elseif 序号 == 100224 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:执法天兵日常(任务id, 玩家id))
	elseif 序号 == 100225 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:随机神兽(任务id, 玩家id))
	elseif 序号 == 100226 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:桃园狸猫(任务id, 玩家id))
	elseif 序号 == 100227 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:虎子战斗(任务id, 玩家id))
	elseif 序号 == 100228 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战灵鹤(任务id, 玩家id))
	elseif 序号 == 100229 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战灵鹤2(任务id, 玩家id))
	elseif 序号 == 100230 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战江南小盗(任务id, 玩家id))
	elseif 序号 == 100231 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战大大龟(任务id, 玩家id))
	elseif 序号 == 100232 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战绿皮蛙(任务id, 玩家id))
	elseif 序号 == 100233 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战屈原(任务id, 玩家id))
	elseif 序号 == 100234 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战狂盗(任务id, 玩家id))
	elseif 序号 == 100235 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战黄狮王(任务id, 玩家id))
	elseif 序号 == 100236 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战马全有(任务id, 玩家id))
	elseif 序号 == 100237 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战海盗头子(任务id, 玩家id))
	elseif 序号 == 100238 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:梦战浪鬼(任务id, 玩家id))
	elseif 序号 == 100239 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:自动抓鬼(任务id, 玩家id))
	elseif 序号 == 100240 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:自动门派(任务id, 玩家id))
	elseif 序号 == 100241 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:自动官职(任务id, 玩家id))
	elseif 序号 == 100243 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:洛树妖(任务id, 玩家id))
	elseif 序号 == 100244 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:赌徒喽啰(任务id, 玩家id))
	elseif 序号 == 100245 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:江州县令(任务id, 玩家id))
	elseif 序号 == 100246 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:江洋大盗(任务id, 玩家id))
	elseif 序号 == 100247 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:洛川鬼(任务id, 玩家id))
	elseif 序号 == 100248 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:妩媚狐仙(任务id, 玩家id))
	elseif 序号 == 100249 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:赌霸城(任务id, 玩家id))
	elseif 序号 == 100250 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:半阁守将(任务id, 玩家id))
	elseif 序号 == 100251 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:流氓兔(任务id, 玩家id))
	elseif 序号 == 100252 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大雁塔塔主(任务id, 玩家id))
	elseif 序号 == 100253 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大雁塔塔主2(任务id, 玩家id))
	elseif 序号 == 100254 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:大雁塔塔主3(任务id, 玩家id))
	elseif 序号 == 100255 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:卷帘大将1(任务id, 玩家id))
	elseif 序号 == 100256 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:卷帘大将2(任务id, 玩家id))
	elseif 序号 == 100257 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:路人甲(任务id, 玩家id))
	elseif 序号 == 100258 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:杨戬(任务id, 玩家id))
	elseif 序号 == 100259 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:龙孙(任务id, 玩家id))
	elseif 序号 == 100260 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:卷帘大将3(任务id, 玩家id))
	elseif 序号 == 100261 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:角色69突破战斗(任务id, 玩家id))
	elseif 序号 == 100262 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:空慈方丈(任务id, 玩家id))
	elseif 序号 == 100263 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:王福来(任务id, 玩家id))
	elseif 序号 == 100264 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:蓝火兽(任务id, 玩家id))
	elseif 序号 == 100265 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:吸血蝙蝠(任务id, 玩家id))
	elseif 序号 == 100266 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:肾宝狼(任务id, 玩家id))
	elseif 序号 == 100242 then
		if 任务数据[任务id].分类 == 1 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取巧智魔信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 2 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取怯弱妖信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 3 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取迷幻妖信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 4 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:取梦魇魔信息(任务id, 玩家id))
		elseif 任务数据[任务id].分类 == 5 then
			self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:万年魔灵(任务id, 玩家id))
		end
	elseif 序号 == 100301 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠鸾儿(任务id, 玩家id))
	elseif 序号 == 100302 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠叶夫人(任务id, 玩家id))
	elseif 序号 == 100303 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠官差(任务id, 玩家id))
	elseif 序号 == 100304 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠沈唐一(任务id, 玩家id))
	elseif 序号 == 100305 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠夜影迷踪(任务id, 玩家id))
	elseif 序号 == 100306 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:一斛珠沈唐二(任务id, 玩家id))
	elseif 序号 == 130041 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_子鼠(任务id, 玩家id))
	elseif 序号 == 130042 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_丑牛(任务id, 玩家id))
	elseif 序号 == 130043 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_寅虎(任务id, 玩家id))
	elseif 序号 == 130044 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_卯兔(任务id, 玩家id))
	elseif 序号 == 130045 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_辰龙(任务id, 玩家id))
	elseif 序号 == 130046 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_巳蛇(任务id, 玩家id))
	elseif 序号 == 130047 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_午马(任务id, 玩家id))
	elseif 序号 == 130048 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_未羊(任务id, 玩家id))
	elseif 序号 == 130049 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_申猴(任务id, 玩家id))
	elseif 序号 == 130050 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_酉鸡(任务id, 玩家id))
	elseif 序号 == 130051 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_戌犬(任务id, 玩家id))
	elseif 序号 == 130052 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:天降星辰_亥猪(任务id, 玩家id))
	elseif 序号 == 130087 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_先锋(任务id, 玩家id))
	elseif 序号 == 130088 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_头目(任务id, 玩家id))
	elseif 序号 == 130089 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_大王(任务id, 玩家id))
	elseif 序号 == 130090 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_魑(任务id, 玩家id))
	elseif 序号 == 130091 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_魅(任务id, 玩家id))
	elseif 序号 == 130092 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_魍(任务id, 玩家id))
	elseif 序号 == 130093 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_魉(任务id, 玩家id))
	elseif 序号 == 130094 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_鼍龙(任务id, 玩家id))
	elseif 序号 == 130095 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_兕怪(任务id, 玩家id))
	elseif 序号 == 130096 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:保卫长安_振威大王(任务id, 玩家id))
	elseif 序号 == 140000 then
		self.战斗盒子[临时id]:进入战斗(玩家id, 序号, 任务id, self:雁塔地宫信息(任务id, 玩家id))
	end
end

function 战斗准备类:取巧智魔信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	local 模型范围 = {
		"野鬼",
		"僵尸",
		"牛头",
		"马面",
		"鬼将",
		"吸血鬼",
		"噬天虎",
		"炎魔神"
	}
	local 怪物名称 = {
		{
			"巧智魔",
			"蜃气妖",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"妖魔巫师",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 8 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.9,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.6,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.6,
				灵力 = 阶段属性[等级].法伤 * 0.6,
				速度 = 阶段属性[等级].速度 * 0.5,
				防御 = 阶段属性[等级].防御 * 0.05,
				法防 = 阶段属性[等级].法防 * 0.05,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取怯弱妖信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 模型范围 = {
		"灵鹤",
		"夜罗刹",
		"幽灵",
		"如意仙子",
		"巡游天神",
		"蛟龙",
		"凤凰",
		"修罗傀儡鬼"
	}
	local 怪物名称 = {
		{
			"怯弱妖",
			"雾中仙",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"妖魔喽啰",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"妖魔巫师",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 7 + ygsj(2) do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.9,
				灵力 = 阶段属性[等级].法伤 * 0.9,
				速度 = 阶段属性[等级].速度 * 1.2,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.75,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.75,
				灵力 = 阶段属性[等级].法伤 * 0.75,
				速度 = 阶段属性[等级].速度 * 0.65,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取迷幻妖信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 2
	local 模型范围 = {
		"百足将军",
		"蚌精",
		"碧水夜叉",
		"巴蛇",
		"藤蔓妖花",
		"曼珠沙华",
		"金身罗汉",
		"修罗傀儡妖"
	}
	local 怪物名称 = {
		{
			"迷幻妖",
			"曼珠沙华",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"妖魔巫师",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 8 + ygsj(2) do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1.3,
				防御 = 阶段属性[等级].防御 * 0.2,
				法防 = 阶段属性[等级].法防 * 0.2,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.85,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取梦魇魔信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 4
	local 模型范围 = {
		"百足将军",
		"蚌精",
		"碧水夜叉",
		"巴蛇",
		"藤蔓妖花",
		"曼珠沙华",
		"金身罗汉",
		"修罗傀儡妖"
	}
	local 怪物名称 = {
		{
			"梦魇魔",
			"炎魔神",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"妖魔战将",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"妖魔巫师",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.2,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.25,
				法防 = 阶段属性[等级].法防 * 0.25,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.9,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.85,
				灵力 = 阶段属性[等级].法伤 * 0.9,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.2,
				法防 = 阶段属性[等级].法防 * 0.2,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:万年魔灵(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 6
	local 模型范围 = {
		"红萼仙子",
		"进阶碧水夜叉",
		"锦毛貂精",
		"巴蛇",
		"藤蔓妖花",
		"曼珠沙华",
		"修罗傀儡鬼",
		"修罗傀儡妖"
	}
	local 怪物名称 = {
		{
			"万年魔灵",
			"九头精怪",
			{
				"高级感知",
				"高级夜战",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"魔灵护法",
			"大力金刚",
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"魔灵护法",
			"大力金刚",
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"魔灵护法",
			"大力金刚",
			{
				"高级法术连击",
				"高级夜战",
				"高级法术暴击",
				"高级法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"妖魔战士",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级必杀",
				"高级夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"妖魔战士",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术连击",
				"敏捷",
				"高级法术暴击",
				"高级法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"妖魔巫师",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.2,
				灵力 = 阶段属性[等级].法伤 * 1.5,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.3,
				躲避 = 阶段属性[等级].躲避 * 1,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.95,
				灵力 = 阶段属性[等级].法伤 * 1.1,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.25,
				法防 = 阶段属性[等级].法防 * 0.25,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠鸾儿(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 武器造型 = {
		级别 = 90,
		武器 = "吹雪"
	}
	战斗单位[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 99999900,
		模型 = "狐美人",
		名称 = "鸾儿姑娘",
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 235 + 等级 * 6.5 * 6,
		灵力 = 等级 * 15,
		速度 = 等级 * 4,
		防御 = 等级 * 8,
		法防 = 等级 * 5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"变身",
			"连环击",
			"鹰击"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "画魂",
		名称 = "清醒意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "画魂",
		名称 = "清醒意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "雾中仙",
		名称 = "清醒意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"龙卷雨击",
			"龙吟",
			"龙腾"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "雾中仙",
		名称 = "清醒意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"龙卷雨击",
			"龙吟",
			"龙腾"
		}
	}
	战斗单位[6] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "进阶蝴蝶仙子",
		名称 = "泪光盈盈",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[7] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "进阶蝴蝶仙子",
		名称 = "泪光盈盈",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[8] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "进阶蝴蝶仙子",
		名称 = "泪光盈盈",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[9] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "芙蓉仙子",
		名称 = "缠绵幽怨",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"裂石",
			"浪涌"
		}
	}
	战斗单位[10] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "芙蓉仙子",
		名称 = "缠绵幽怨",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"似玉生香"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠叶夫人(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 武器造型 = {
		级别 = 90,
		武器 = "月光双剑"
	}
	战斗单位[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 99999900,
		模型 = "飞燕女",
		名称 = "叶夫人",
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 235 + 等级 * 6.5 * 6,
		灵力 = 等级 * 13,
		速度 = 等级 * 4,
		防御 = 等级 * 8,
		法防 = 等级 * 5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"龙卷雨击",
			"龙吟",
			"龙腾"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "画魂",
		名称 = "疯狂意识",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"百爪狂杀"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "画魂",
		名称 = "疯狂意识",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"百爪狂杀"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "阴阳伞",
		名称 = "疯狂意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"催眠符",
			"失心符",
			"落雷符"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "阴阳伞",
		名称 = "疯狂意识",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"催眠符",
			"失心符",
			"落雷符"
		}
	}
	战斗单位[6] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "藤蔓妖花",
		名称 = "切肤之痛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[7] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "藤蔓妖花",
		名称 = "切肤之痛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[8] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "藤蔓妖花",
		名称 = "切肤之痛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[9] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "夜罗刹",
		名称 = "黯然神伤",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"高级连击",
			"高级必杀"
		},
		主动技能 = {}
	}
	战斗单位[10] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "夜罗刹",
		名称 = "黯然神伤",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 130,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"高级连击",
			"高级必杀"
		},
		主动技能 = {}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠官差(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 99999900,
		模型 = "天兵",
		名称 = "官差",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 235 + 等级 * 6.5 * 6 + 等级 * 6.5 * 6,
		灵力 = 等级 * 12,
		速度 = 等级 * 4,
		防御 = 等级 * 8,
		法防 = 等级 * 2,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "天兵",
		名称 = "官差帮手",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 4,
		防御 = 等级 * 3,
		法防 = 等级 * 2,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "天兵",
		名称 = "官差帮手",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 4,
		防御 = 等级 * 3,
		法防 = 等级 * 2,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "巡游天神",
		名称 = "官差帮手",
		伤害 = 等级 * 14,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 4,
		防御 = 等级 * 3,
		法防 = 等级 * 2,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"后发制人",
			"杀气诀"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "巡游天神",
		名称 = "官差帮手",
		伤害 = 等级 * 14,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 4,
		防御 = 等级 * 3,
		法防 = 等级 * 2,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"后发制人",
			"反间之计"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠沈唐一(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 武器造型 = {
		级别 = 160,
		武器 = "星瀚"
	}
	战斗单位[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 99999900,
		防御修炼 = 0,
		模型 = "逍遥生",
		名称 = "沈唐",
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		伤害 = 等级 * 16,
		气血 = (等级 - 5 + 等级 * 0.2) * 235 + 等级 * 6.5 * 6,
		灵力 = 等级 * 12.5,
		速度 = 等级 * 4,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"横扫千军",
			"后发制人",
			"破血狂攻"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "蛟龙",
		名称 = "玉鳞蛟",
		伤害 = 等级 * 14,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"百爪狂杀",
			"阎罗令",
			"尸腐毒"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "蛟龙",
		名称 = "玉鳞蛟",
		伤害 = 等级 * 14,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"百爪狂杀",
			"阎罗令",
			"尸腐毒"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "蛟龙",
		名称 = "锦云蛟",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "蛟龙",
		名称 = "锦云蛟",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[6] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "曼珠沙华",
		名称 = "珊瑚灵妖",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[7] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "曼珠沙华",
		名称 = "珊瑚灵妖",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[8] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "曼珠沙华",
		名称 = "珊瑚灵妖",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[9] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "修罗傀儡鬼",
		名称 = "金藻傀儡",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"破血狂攻",
			"浪涌"
		}
	}
	战斗单位[10] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "修罗傀儡鬼",
		名称 = "金藻傀儡",
		伤害 = 等级 * 15,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 8,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"破血狂攻",
			"浪涌"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠夜影迷踪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "蛟龙",
		名称 = "夜影迷踪",
		伤害 = 等级 * 12,
		气血 = (等级 - 5 + 等级 * 0.2) * 170 + 等级 * 6.5 * 6 + 等级 * 6.5 * 6,
		灵力 = 等级 * 10,
		速度 = 等级 * 4,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "蚌精",
		名称 = "孤苦蚌精",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 110,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"法术连击"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		模型 = "蚌精",
		名称 = "孤苦蚌精",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 110,
		灵力 = 等级 * 10,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"法术连击"
		},
		主动技能 = {
			"水漫金山"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "鲛人",
		名称 = "潦倒鲛人",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 110,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级必杀"
		},
		主动技能 = {
			"壁垒击破"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "鲛人",
		名称 = "潦倒鲛人",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 110,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级必杀"
		},
		主动技能 = {
			"壁垒击破"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:一斛珠沈唐二(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 99999900,
		模型 = "鲛人",
		名称 = "沈唐真身",
		伤害 = 等级 * 16,
		气血 = (等级 - 5 + 等级 * 0.2) * 235 + 等级 * 6.5 * 6,
		灵力 = 等级 * 10,
		速度 = 等级 * 4,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级夜战"
		},
		主动技能 = {
			"浪涌",
			"破血狂攻"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[2] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "噬天虎",
		名称 = "悲歌",
		伤害 = 等级 * 14.5,
		气血 = (等级 - 5 + 等级 * 0.2) * 190,
		灵力 = 等级 * 7,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"变身",
			"鹰击"
		}
	}
	战斗单位[3] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "噬天虎",
		名称 = "悲歌",
		伤害 = 等级 * 14.5,
		气血 = (等级 - 5 + 等级 * 0.2) * 190,
		灵力 = 等级 * 7,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"变身",
			"鹰击"
		}
	}
	战斗单位[4] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "蚌精",
		名称 = "欢喜",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 190,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[5] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "蚌精",
		名称 = "欢喜",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 190,
		灵力 = 等级 * 8,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[6] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "混沌兽",
		名称 = "沧浪之涛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10.5,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级驱鬼"
		},
		主动技能 = {
			"上古灵符"
		}
	}
	战斗单位[7] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "混沌兽",
		名称 = "沧浪之涛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10.5,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级驱鬼"
		},
		主动技能 = {
			"上古灵符"
		}
	}
	战斗单位[8] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "混沌兽",
		名称 = "沧浪之涛",
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 10.5,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级驱鬼"
		},
		主动技能 = {
			"上古灵符"
		}
	}
	战斗单位[9] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "碧水夜叉",
		名称 = "荒墟之悲",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"夜战"
		},
		主动技能 = {
			"壁垒击破"
		}
	}
	战斗单位[10] = {
		魔法 = 99999900,
		愤怒 = 9999,
		变异 = true,
		模型 = "碧水夜叉",
		名称 = "荒墟之悲",
		伤害 = 等级 * 13,
		气血 = (等级 - 5 + 等级 * 0.2) * 170,
		灵力 = 等级 * 7,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		等级 = 等级,
		技能 = {
			"高级感知",
			"夜战"
		},
		主动技能 = {
			"壁垒击破"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:齐天黑无常(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 1.3,
		饰品 = true,
		变异 = true,
		魔法 = 10,
		躲避 = 1,
		法伤 = 1,
		速度 = 0.6,
		模型 = "野鬼",
		名称 = "黑无常",
		法防 = 0.2,
		防御 = 0.2,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级连击"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:齐天白无常(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 0.8,
		气血 = 1.3,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 0.6,
		防御 = 0.2,
		法防 = 0.2,
		躲避 = 1,
		法伤 = 1.1,
		模型 = "僵尸",
		名称 = "白无常",
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级魔之心",
			"高级法术暴击",
			"高级法术连击"
		},
		主动技能 = {
			"烈火",
			"地狱烈火"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:齐天阎王(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.8,
		饰品 = true,
		变异 = true,
		魔法 = 10,
		躲避 = 1,
		法伤 = 1.2,
		速度 = 0.7,
		模型 = "鬼将",
		名称 = "冥府鬼将",
		法防 = 0.3,
		防御 = 0.3,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级连击",
			"嗜血追击",
			"烈焰斩"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "野鬼",
		名称 = "鬼差",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"善恶有报",
			"舍身一搏"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "野鬼",
		名称 = "鬼差",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"善恶有报",
			"舍身一搏"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.4,
		模型 = "巡游天神",
		名称 = "斩妖",
		防御 = 0.1,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.3,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "灾",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "吸血鬼",
		名称 = "鬼兵",
		防御 = 0.15,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:齐天天王(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 1.1,
		气血 = 1.8,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 0.7,
		防御 = 0.3,
		法防 = 0.3,
		躲避 = 1,
		法伤 = 1.2,
		模型 = "大力金刚",
		名称 = "大力神王",
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级强力"
		},
		主动技能 = {
			"力劈华山"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"剑气四射"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.4,
		模型 = "进阶地狱战神",
		名称 = "镇妖",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.4,
		模型 = "进阶地狱战神",
		名称 = "镇妖",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.3,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "踏云兽",
		名称 = "降兽",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"高级连击"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:齐天盗马贼(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		饰品 = true,
		变异 = true,
		魔法 = 10,
		躲避 = 1,
		法伤 = 1,
		速度 = 0.4,
		法防 = 0.2,
		防御 = 0.2,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级强力",
			"连击"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.9,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.3,
		防御 = 0.1,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"烈火"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:大闹百万天兵(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 1,
		气血 = 2,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1,
		防御 = 0.4,
		法防 = 0.4,
		躲避 = 1,
		法伤 = 1.3,
		模型 = "风伯",
		名称 = "百万天兵",
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = 夜光随机法术(3)
	}
	阵容.怪物数据[2] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"剑气四射"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.5,
		法防 = 0.3,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.3,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.2,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"高级连击"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.3,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 1,
		模型 = "阴阳伞",
		名称 = "天弄",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:大闹巨灵神(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 1.3,
		气血 = 2,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1,
		防御 = 0.4,
		法防 = 0.4,
		躲避 = 1,
		法伤 = 1,
		模型 = "大力金刚",
		名称 = "巨灵神",
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级强力"
		},
		主动技能 = {
			"力劈华山"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "天兵",
		名称 = "天兵",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"剑气四射"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "进阶地狱战神",
		名称 = "镇妖",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "进阶地狱战神",
		名称 = "镇妖",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.5,
		法防 = 0.3,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.3,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.2,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "踏云兽",
		名称 = "降兽",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"高级连击"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.3,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 1,
		模型 = "阴阳伞",
		名称 = "天弄",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:大闹镇塔之神(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 1.3,
		气血 = 2,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1,
		防御 = 0.4,
		法防 = 0.4,
		躲避 = 1,
		法伤 = 1.5,
		模型 = "护卫",
		名称 = "镇塔神灵",
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级强力"
		},
		主动技能 = {
			"力劈华山"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "龙龟",
		名称 = "镇塔玄龟",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.4,
		模型 = "龙龟",
		名称 = "镇塔玄龟",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"剑气四射"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "凤凰",
		名称 = "宝塔玄火",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动",
			"火属性吸收"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.1,
		速度 = 0.4,
		模型 = "凤凰",
		名称 = "宝塔玄火",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"法术暴击",
			"法术连击",
			"法术波动",
			"火属性吸收"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.5,
		法防 = 0.3,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "混沌兽",
		名称 = "天罚",
		防御 = 0.3,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.45,
		模型 = "夜罗刹",
		名称 = "天灾",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1.5,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.5,
		法伤 = 1.5,
		速度 = 0.8,
		模型 = "葫芦宝贝",
		名称 = "天恩",
		防御 = 0.5,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"地涌金莲",
			"推气过宫",
			"普渡众生"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.3,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 1,
		模型 = "阴阳伞",
		名称 = "天弄",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:更新(dt)
	for n, v in pairs(self.战斗盒子) do
		if self.战斗盒子[n] ~= nil then
			self.战斗盒子[n]:更新(n)
		end

		if self.战斗盒子[n].结束条件 then
			self.战斗盒子[n] = nil
		end
	end
end

function 战斗准备类:数据处理(玩家id, 序号, 内容, 参数)
	if 玩家数据[玩家id].战斗 == 0 or self.战斗盒子[玩家数据[玩家id].战斗] == nil then
		return 0
	else
		self.战斗盒子[玩家数据[玩家id].战斗]:数据处理(玩家id, 序号, 内容, 参数)
	end
end

function 战斗准备类:取剑会天下随机属性1(门派, 等级)
	local 随机门派 = 取随机数()
	local 返回数据 = {}

	if 门派 == "狮驼岭" or 门派 == "大唐官府" or 门派 == "凌波城" or 门派 == "天宫" or 门派 == "花果山" or 门派 == "天机城" or 门派 == "九黎城" then
		if 随机门派 <= 15 then
			local 角色模型 = {
				"杀破狼",
				"虎头怪",
				"巨魔王"
			}
			返回数据.门派 = "狮驼岭"
			返回数据.技能 = {
				"鹰击"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {
				{
					名称 = "变身",
					等级 = 等级
				}
			}
		elseif 随机门派 <= 30 then
			local 角色模型 = {
				"飞燕女",
				"英女侠",
				"巫蛮儿",
				"偃无师",
				"逍遥生",
				"剑侠客"
			}
			返回数据.门派 = "大唐官府"
			返回数据.技能 = {
				"横扫千军",
				"后发制人"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 45 then
			local 角色模型 = {
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "大唐官府"
			返回数据.技能 = {
				"横扫千军"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 60 then
			local 角色模型 = {
				"舞天姬",
				"玄彩娥",
				"桃夭夭",
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "凌波城"
			返回数据.技能 = {
				"浪涌"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 60 then
			local 角色模型 = {
				"舞天姬",
				"玄彩娥",
				"桃夭夭",
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "大唐官府"
			返回数据.技能 = {
				"横扫千军"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		else
			local 角色模型 = {
				"舞天姬",
				"玄彩娥",
				"桃夭夭",
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "天宫"
			返回数据.技能 = {
				"天雷斩"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		end
	elseif 门派 == "龙宫" or 门派 == "神木林" or 门派 == "魔王寨" then
		if 随机门派 <= 33 then
			local 角色模型 = {
				"舞天姬",
				"玄彩娥",
				"桃夭夭",
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "龙宫"
			返回数据.技能 = {
				"龙卷雨击",
				"龙腾"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 66 then
			local 角色模型 = {
				"飞燕女",
				"英女侠",
				"巫蛮儿",
				"偃无师",
				"逍遥生",
				"剑侠客"
			}
			返回数据.门派 = "神木林"
			返回数据.技能 = {
				"落叶萧萧"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		else
			local 角色模型 = {
				"骨精灵",
				"狐美人",
				"鬼潇潇",
				"杀破狼",
				"虎头怪",
				"巨魔王"
			}
			返回数据.门派 = "魔王寨"
			返回数据.技能 = {
				"飞砂走石"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		end
	elseif 门派 == "化生寺" or 门派 == "普陀山" or 门派 == "无底洞" or 门派 == "阴曹地府" then
		if 随机门派 <= 25 then
			local 角色模型 = {
				"偃无师",
				"逍遥生",
				"剑侠客"
			}
			返回数据.门派 = "化生寺"
			返回数据.技能 = {
				"推气过宫"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 50 then
			local 角色模型 = {
				"舞天姬",
				"玄彩娥",
				"桃夭夭"
			}
			返回数据.门派 = "普陀山"
			返回数据.技能 = {
				"普渡众生"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 75 then
			local 角色模型 = {
				"骨精灵",
				"狐美人",
				"鬼潇潇",
				"杀破狼",
				"虎头怪",
				"巨魔王"
			}
			返回数据.门派 = "阴曹地府"
			返回数据.技能 = {
				"阎罗令"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		else
			local 角色模型 = {
				"骨精灵",
				"狐美人",
				"鬼潇潇",
				"杀破狼",
				"虎头怪",
				"巨魔王"
			}
			返回数据.门派 = "无底洞"
			返回数据.技能 = {
				"地涌金莲"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		end
	elseif 门派 == "盘丝洞" or 门派 == "方寸山" or 门派 == "五庄观" or 门派 == "女儿村" then
		if 随机门派 <= 25 then
			local 角色模型 = {
				"骨精灵",
				"狐美人",
				"鬼潇潇"
			}
			返回数据.门派 = "无底洞"
			返回数据.技能 = {
				"含情脉脉"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 50 then
			local 角色模型 = {
				"飞燕女",
				"英女侠",
				"巫蛮儿",
				"偃无师",
				"逍遥生",
				"剑侠客"
			}
			返回数据.门派 = "方寸山"
			返回数据.技能 = {
				"定身符",
				"失心符"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		elseif 随机门派 <= 75 then
			local 角色模型 = {
				"龙太子",
				"神天兵",
				"羽灵神"
			}
			返回数据.门派 = "五庄观"
			返回数据.技能 = {
				"日月乾坤"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		else
			local 角色模型 = {
				"飞燕女",
				"英女侠",
				"巫蛮儿"
			}
			返回数据.门派 = "女儿村"
			返回数据.技能 = {
				"似玉生香",
				"满天花雨"
			}
			返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
			返回数据.奇经八脉 = {}
			返回数据.法宝 = {
				{
					名称 = "金甲仙衣",
					境界 = 9
				}
			}
			返回数据.追加法术 = {}
			返回数据.附加状态 = {}
		end
	end

	return 返回数据
end

function 战斗准备类:取剑会天下随机属性(门派, 等级)
	local 随机门派 = 取随机数(1, 225)
	local 返回数据 = {}

	if 随机门派 <= 15 then
		local 角色模型 = {
			"杀破狼",
			"虎头怪",
			"巨魔王"
		}
		返回数据.门派 = "狮驼岭"
		返回数据.技能 = {
			"鹰击",
			"狮搏",
			"象形",
			"连环击"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			宁息 = 1,
			化血 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {
			{
				名称 = "变身",
				等级 = 等级
			}
		}
	elseif 随机门派 <= 30 then
		local 角色模型 = {
			"飞燕女",
			"英女侠",
			"巫蛮儿",
			"偃无师",
			"逍遥生",
			"剑侠客"
		}
		返回数据.门派 = "大唐官府"
		返回数据.技能 = {
			"横扫千军",
			"后发制人",
			"破釜沉舟",
			"杀气诀"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			杀意 = 1,
			无敌 = 1,
			风刃 = 1,
			干将 = 1,
			破军 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 45 then
		local 角色模型 = {
			"舞天姬",
			"玄彩娥",
			"桃夭夭",
			"龙太子",
			"神天兵",
			"羽灵神"
		}
		返回数据.门派 = "凌波城"
		返回数据.技能 = {
			"天崩地裂",
			"翻江搅海",
			"碎星诀",
			"浪涌"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			战诀 = 1,
			天神怒斩 = 1,
			暴气 = 1,
			真君显灵 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 60 then
		local 角色模型 = {
			"舞天姬",
			"玄彩娥",
			"桃夭夭",
			"龙太子",
			"神天兵",
			"羽灵神"
		}
		返回数据.门派 = "天宫"
		返回数据.技能 = {
			"天雷斩",
			"雷霆万钧",
			"雷霆万钧",
			"天神护体",
			"天神护法"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			威赫 = 1,
			画地为牢 = 1,
			月桂 = 1,
			怒气 = 1,
			神律 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 75 then
		local 角色模型 = {
			"舞天姬",
			"玄彩娥",
			"桃夭夭",
			"龙太子",
			"神天兵",
			"羽灵神"
		}
		返回数据.门派 = "龙宫"
		返回数据.技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 90 then
		local 角色模型 = {
			"飞燕女",
			"英女侠",
			"巫蛮儿",
			"偃无师",
			"逍遥生",
			"剑侠客"
		}
		返回数据.门派 = "神木林"
		返回数据.技能 = {
			"落叶萧萧",
			"蜜润",
			"风卷残云"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			法身 = 1,
			风灵 = 1,
			滋养 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 105 then
		local 角色模型 = {
			"骨精灵",
			"狐美人",
			"鬼潇潇",
			"杀破狼",
			"虎头怪",
			"巨魔王"
		}
		返回数据.门派 = "魔王寨"
		返回数据.技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 120 then
		local 角色模型 = {
			"偃无师",
			"逍遥生",
			"剑侠客"
		}
		返回数据.门派 = "化生寺"
		返回数据.技能 = {
			"推气过宫",
			"活血",
			"金刚护体",
			"金刚护法",
			"唧唧歪歪"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			诸天看护 = 1,
			舍利 = 1,
			心韧 = 1,
			佛显 = 1,
			映法 = 1,
			佛誉 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 135 then
		local 角色模型 = {
			"舞天姬",
			"玄彩娥",
			"桃夭夭"
		}
		返回数据.门派 = "普陀山"
		返回数据.技能 = {
			"普渡众生",
			"波澜不惊",
			"晶清诀",
			"五行制化",
			"灵动九天"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			普渡 = 1,
			借灵 = 1,
			道衍 = 1,
			雨润 = 1,
			秘术 = 1,
			法咒 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 150 then
		local 角色模型 = {
			"骨精灵",
			"狐美人",
			"鬼潇潇",
			"杀破狼",
			"虎头怪",
			"巨魔王"
		}
		返回数据.门派 = "阴曹地府"
		返回数据.技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 165 then
		local 角色模型 = {
			"骨精灵",
			"狐美人",
			"鬼潇潇",
			"杀破狼",
			"虎头怪",
			"巨魔王"
		}
		返回数据.门派 = "无底洞"
		返回数据.技能 = {
			"地涌金莲",
			"夺命咒",
			"金身舍利",
			"摧心术",
			"明光宝烛",
			"同舟共济"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			化莲 = 1,
			金莲 = 1,
			自愈 = 1,
			精进 = 1,
			反先 = 1,
			同舟共济 = 1,
			灵身 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 180 then
		local 角色模型 = {
			"骨精灵",
			"狐美人",
			"鬼潇潇"
		}
		返回数据.门派 = "盘丝洞"
		返回数据.技能 = {
			"含情脉脉",
			"瘴气",
			"魔音摄魂",
			"盘丝阵",
			"幻镜术",
			"天罗地网"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			脱壳 = 1,
			情劫 = 1,
			迷梦 = 1,
			鼓乐 = 1,
			结阵 = 1,
			粘附 = 1,
			媚态 = 1,
			迷意 = 1,
			妖气 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 195 then
		local 角色模型 = {
			"飞燕女",
			"英女侠",
			"巫蛮儿",
			"偃无师",
			"逍遥生",
			"剑侠客"
		}
		返回数据.门派 = "方寸山"
		返回数据.技能 = {
			"碎甲符",
			"定身符",
			"失心符",
			"五雷咒",
			"落雷符",
			"分身术"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			不倦 = 1,
			苦缠 = 1,
			化身 = 1,
			雷动 = 1,
			奔雷 = 1,
			鬼念 = 1,
			碎甲 = 1,
			批亢 = 1,
			鬼惧 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 210 then
		local 角色模型 = {
			"龙太子",
			"神天兵",
			"羽灵神"
		}
		返回数据.门派 = "五庄观"
		返回数据.技能 = {
			"日月乾坤",
			"飘渺式",
			"烟雨剑法",
			"生命之泉"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			乾坤 = 1,
			雨杀 = 1,
			修心 = 1,
			意境 = 1,
			傲视 = 1,
			陌宝 = 1,
			养生 = 1,
			锤炼 = 1,
			混元 = 1,
			心随意动 = 1,
			同辉 = 1,
			体恤 = 1,
			归本 = 1,
			致命 = 1,
			神附 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	elseif 随机门派 <= 225 then
		local 角色模型 = {
			"飞燕女",
			"英女侠",
			"巫蛮儿"
		}
		返回数据.门派 = "女儿村"
		返回数据.技能 = {
			"一笑倾城",
			"满天花雨",
			"红袖添香",
			"雨落寒沙"
		}
		返回数据.模型 = 角色模型[取随机数(1, #角色模型)]
		返回数据.奇经八脉 = {
			毒引 = 1,
			倩影 = 1,
			毒雾 = 1,
			嫣然 = 1,
			磐石 = 1,
			轻霜 = 1,
			杏花 = 1,
			暗伤 = 1,
			天香 = 1,
			鸿影 = 1,
			花舞 = 1,
			自矜 = 1,
			淬芒 = 1
		}
		返回数据.法宝 = {
			{
				名称 = "金甲仙衣",
				境界 = 9
			}
		}
		返回数据.追加法术 = {}
		返回数据.附加状态 = {}
	end

	return 返回数据
end

function 战斗准备类:取剑会天下BB技能1(属性, 技能)
	local 最高属性 = {
		"力量",
		0
	}

	for n, v in pairs(属性) do
		if 最高属性[2] < v then
			最高属性[1] = n
			最高属性[2] = v
		end
	end

	if 最高属性[2] == 属性.力量 then
		最高属性[1] = "力量"
	end

	if 最高属性[1] == "力量" then
		local 高级技能 = {
			"高级必杀",
			"高级再生",
			"高级幸运",
			"高级吸血",
			"高级反震",
			"高级吸血",
			"高级反击",
			"嗜血追击",
			"从天而降",
			"高级驱怪",
			"苍鸾怒击",
			"高级连击",
			"高级飞行",
			"高级感知",
			"高级再生",
			"高级必杀",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级敏捷",
			"高级强力",
			"高级防御",
			"高级偷袭",
			"高级毒",
			"高级驱鬼",
			"高级鬼魂术",
			"高级神佑复生",
			"高级否定信仰",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"善恶有报",
			"力劈华山",
			"惊心一剑",
			"剑荡四方",
			"壁垒击破",
			"力劈华山",
			"死亡召唤",
			"夜舞倾城",
			"理直气壮",
			"烈火",
			"雷击",
			"水攻",
			"落岩",
			"上古灵符"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(12, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		for n = 1, #主动技能 do
			for i = 1, #主动技能 do
				if 主动技能[n] == 主动技能[i] then
					数量 = 数量 + 1
					返回.主动技能[#返回.主动技能 + 1] = 主动技能[n]

					table.remove(主动技能, i)

					break
				end
			end
		end

		if #主动技能 - 数量 > 0 then
			for n = 1, #主动技能 - 数量 do
				local jns = 取随机数(5, #主动技能)
				返回.主动技能[#返回.主动技能 + 1] = 主动技能[jns]

				table.remove(主动技能, jns)
			end
		end

		return 返回
	elseif 最高属性[1] == "魔力" then
		local 高级技能 = {
			"高级反震",
			"高级飞行",
			"须弥真言",
			"高级感知",
			"高级冥思",
			"高级慧根",
			"高级再生",
			"高级幸运",
			"高级神迹",
			"高级永恒",
			"高级敏捷",
			"高级防御",
			"高级驱鬼",
			"高级鬼魂术",
			"高级魔之心",
			"高级神佑复生",
			"龙魂",
			"高级精神集中",
			"高级否定信仰",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"善恶有报",
			"力劈华山",
			"惊心一剑",
			"剑荡四方",
			"壁垒击破",
			"力劈华山",
			"死亡召唤",
			"夜舞倾城",
			"理直气壮",
			"烈火",
			"雷击",
			"水攻",
			"落岩",
			"上古灵符"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(12, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		for n = 1, #主动技能 do
			for i = 1, #主动技能 do
				if 主动技能[n] == 主动技能[i] then
					数量 = 数量 + 1
					返回.主动技能[#返回.主动技能 + 1] = 主动技能[n]

					table.remove(主动技能, i)

					break
				end
			end
		end

		if #主动技能 - 数量 > 0 then
			for n = 1, #主动技能 - 数量 do
				local jns = 取随机数(5, #主动技能)
				返回.主动技能[#返回.主动技能 + 1] = 主动技能[jns]

				table.remove(主动技能, jns)
			end
		end

		return 返回
	else
		local 高级技能 = {
			"高级毒",
			"高级反震",
			"高级飞行",
			"高级感知",
			"高级冥思",
			"高级慧根",
			"高级再生",
			"高级幸运",
			"高级神迹",
			"高级永恒",
			"高级敏捷",
			"高级防御",
			"高级驱鬼",
			"高级鬼魂术",
			"高级神佑复生",
			"高级精神集中",
			"高级否定信仰",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"善恶有报",
			"力劈华山",
			"惊心一剑",
			"剑荡四方",
			"壁垒击破",
			"力劈华山",
			"死亡召唤",
			"夜舞倾城",
			"理直气壮",
			"烈火",
			"雷击",
			"水攻",
			"落岩",
			"上古灵符"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(12, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		for n = 1, #主动技能 do
			for i = 1, #主动技能 do
				if 主动技能[n] == 主动技能[i] then
					数量 = 数量 + 1
					返回.主动技能[#返回.主动技能 + 1] = 主动技能[n]

					table.remove(主动技能, i)

					break
				end
			end
		end

		if #主动技能 - 数量 > 0 then
			for n = 1, #主动技能 - 数量 do
				local jns = 取随机数(5, #主动技能)
				返回.主动技能[#返回.主动技能 + 1] = 主动技能[jns]

				table.remove(主动技能, jns)
			end
		end

		return 返回
	end
end

function 战斗准备类:取剑会天下BB技能(属性, 技能)
	local 最高属性 = {
		"力量",
		0
	}

	for n, v in pairs(属性) do
		if 最高属性[2] < v then
			最高属性[1] = n
			最高属性[2] = v
		end
	end

	if 最高属性[2] == 属性.力量 then
		最高属性[1] = "力量"
	end

	if 最高属性[1] == "力量" then
		local 高级技能 = {
			"从天而降",
			"嗜血追击",
			"须弥真言",
			"灵能激发",
			"高级反震",
			"高级吸血",
			"高级反击",
			"高级连击",
			"高级飞行",
			"高级夜战",
			"高级隐身",
			"高级感知",
			"高级再生",
			"高级冥思",
			"高级慧根",
			"高级必杀",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级敏捷",
			"高级强力",
			"高级法术抵抗",
			"高级防御",
			"高级偷袭",
			"高级毒",
			"高级驱鬼",
			"高级鬼魂术",
			"高级魔之心",
			"高级神佑复生",
			"高级精神集中",
			"高级否定信仰",
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"壁垒击破",
			"法术防御",
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"八凶法阵",
			"月光",
			"天降灵葫",
			"上古灵符",
			"叱咤风云",
			"力劈华山",
			"剑荡四方",
			"死亡召唤",
			"善恶有报",
			"壁垒击破",
			"惊心一剑"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(1, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		返回.主动技能 = {
			主动技能[取随机数(1, #主动技能)]
		}

		return 返回
	elseif 最高属性[1] == "魔力" then
		local 高级技能 = {
			"从天而降",
			"嗜血追击",
			"须弥真言",
			"灵能激发",
			"高级反震",
			"高级吸血",
			"高级反击",
			"高级连击",
			"高级飞行",
			"高级夜战",
			"高级隐身",
			"高级感知",
			"高级再生",
			"高级冥思",
			"高级慧根",
			"高级必杀",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级敏捷",
			"高级强力",
			"高级法术抵抗",
			"高级防御",
			"高级偷袭",
			"高级毒",
			"高级驱鬼",
			"高级鬼魂术",
			"高级魔之心",
			"高级神佑复生",
			"高级精神集中",
			"高级否定信仰",
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"壁垒击破",
			"法术防御",
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"八凶法阵",
			"月光",
			"天降灵葫",
			"上古灵符",
			"叱咤风云",
			"力劈华山",
			"剑荡四方",
			"死亡召唤",
			"善恶有报",
			"壁垒击破",
			"惊心一剑"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(1, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		返回.主动技能 = {
			主动技能[取随机数(1, #主动技能)]
		}

		return 返回
	else
		local 高级技能 = {
			"从天而降",
			"嗜血追击",
			"须弥真言",
			"灵能激发",
			"高级反震",
			"高级吸血",
			"高级反击",
			"高级连击",
			"高级飞行",
			"高级夜战",
			"高级隐身",
			"高级感知",
			"高级再生",
			"高级冥思",
			"高级慧根",
			"高级必杀",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级敏捷",
			"高级强力",
			"高级法术抵抗",
			"高级防御",
			"高级偷袭",
			"高级毒",
			"高级驱鬼",
			"高级鬼魂术",
			"高级魔之心",
			"高级神佑复生",
			"高级精神集中",
			"高级否定信仰",
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级雷属性吸收",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级水属性吸收"
		}
		local 主动技能 = {
			"壁垒击破",
			"法术防御",
			"奔雷咒",
			"泰山压顶",
			"水漫金山",
			"地狱烈火",
			"八凶法阵",
			"月光",
			"天降灵葫",
			"上古灵符",
			"叱咤风云",
			"力劈华山",
			"剑荡四方",
			"死亡召唤",
			"善恶有报",
			"壁垒击破",
			"惊心一剑"
		}
		local 数量 = 0
		local 返回 = {
			技能 = {},
			主动技能 = {}
		}

		for n = 1, #技能 do
			for i = 1, #高级技能 do
				if 技能[n] == 高级技能[i] then
					数量 = 数量 + 1
					返回.技能[#返回.技能 + 1] = 技能[n]

					table.remove(高级技能, i)

					break
				end
			end
		end

		if #技能 - 数量 > 0 then
			for n = 1, #技能 - 数量 do
				local jns = 取随机数(1, #高级技能)
				返回.技能[#返回.技能 + 1] = 高级技能[jns]

				table.remove(高级技能, jns)
			end
		end

		返回.主动技能 = {
			主动技能[取随机数(1, #主动技能)]
		}

		return 返回
	end
end

function 战斗准备类:取剑会天下属性(假人属性)
	local 假人随机阵法 = {
		"普通",
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {
		阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]
	}

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 150,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				伤害 = math.floor(假人属性[i].伤害 * 1.1),
				气血 = math.floor(假人属性[i].气血 * 1.1),
				灵力 = math.floor(假人属性[i].灵力 * 1.1),
				速度 = math.floor(假人属性[i].速度 * 1.1),
				防御 = math.floor(假人属性[i].防御 * 1.1),
				法防 = math.floor(假人属性[i].法防 * 1.1),
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(175, 假人属性[i].参战等级)[2]
			战斗单位[i] = {
				名称 = 模型名称,
				模型 = 模型名称,
				伤害 = math.floor(假人属性[i].伤害 * 0.9),
				气血 = math.floor(假人属性[i].气血 * 0.9),
				灵力 = math.floor(假人属性[i].灵力 * 0.9),
				速度 = math.floor(假人属性[i].速度 * 0.9),
				防御 = math.floor(假人属性[i].防御 * 0.9),
				法防 = math.floor(假人属性[i].法防 * 0.9),
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:蚩尤大战(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 战斗单位 = {
		{
			气血 = 500000,
			愤怒 = 9999,
			不可封印 = true,
			抗法修炼 = 25,
			魔法 = 9999999999.0,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶蚩尤",
			名称 = "蚩尤",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"武神怒击",
				"刀光剑影",
				"毁灭之光"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 300000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶持国巡守",
			名称 = "厚土",
			等级 = 175,
			技能 = {
				"高级感知",
				"高级再生",
				"高级驱鬼"
			},
			主动技能 = {
				"金刚护体",
				"金刚护法",
				"晶清诀",
				"罗汉金钟",
				"圣灵之甲",
				"河东狮吼",
				"唧唧歪歪"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶毗舍童子",
			名称 = "搻兹",
			等级 = 175,
			技能 = {
				"高级敏捷",
				"高级吸血",
				"高级必杀",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶蜃气妖",
			名称 = "奢比尸",
			等级 = 175,
			技能 = {
				"高级敏捷",
				"高级吸血",
				"高级必杀",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶真陀护法",
			名称 = "玄冥",
			等级 = 175,
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"三昧真火",
				"地狱烈火",
				"飞砂走石",
				"龙卷雨击",
				"泰山压顶",
				"奔雷咒",
				"水漫金山"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶巨力神猿",
			名称 = "强良",
			等级 = 175,
			技能 = {
				"高级敏捷",
				"高级吸血",
				"高级必杀",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶凤凰",
			名称 = "祝融",
			等级 = 175,
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"三昧真火",
				"地狱烈火",
				"飞砂走石",
				"龙卷雨击",
				"泰山压顶",
				"奔雷咒",
				"水漫金山"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 100000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 2000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶蛟龙",
			名称 = "共工",
			等级 = 175,
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"三昧真火",
				"地狱烈火",
				"飞砂走石",
				"龙卷雨击",
				"泰山压顶",
				"奔雷咒",
				"水漫金山"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 25,
			不可封印 = true,
			气血 = 300000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 3000,
			攻击修炼 = 25,
			防御 = 2000,
			防御修炼 = 25,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 25,
			模型 = "进阶律法女娲",
			名称 = "蓐收",
			等级 = 175,
			技能 = {
				"高级敏捷",
				"高级吸血",
				"高级必杀",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"阎罗令",
				"天罗地网",
				"夺命咒",
				"五行制化",
				"雨落寒沙"
			}
		},
		{
			愤怒 = 9999,
			抗法修炼 = 20,
			气血 = 300000,
			魔法 = 9999999999.0,
			饰品 = true,
			灵力 = 8000,
			速度 = 3000,
			攻击修炼 = 20,
			防御 = 2000,
			防御修炼 = 20,
			法防 = 2000,
			躲避 = 2000,
			伤害 = 6000,
			法术修炼 = 20,
			模型 = "进阶吸血鬼",
			名称 = "天昊",
			等级 = 175,
			技能 = {
				"高级敏捷",
				"高级吸血",
				"高级必杀",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"碎甲符",
				"瘴气",
				"一笑倾城",
				"飞花摘叶",
				"碎玉弄影"
			}
		},
		阵法 = "虎翼阵"
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:桃园蚩尤(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 战斗单位 = {
		{
			气血 = 100000,
			愤怒 = 999,
			抗法修炼 = 20,
			魔法 = 100000,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶蚩尤",
			名称 = "蚩尤",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击",
				"鬼魂术"
			},
			主动技能 = {
				"武神怒击",
				"刀光剑影",
				"毁灭之光"
			}
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶持国巡守",
			名称 = "厚土",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机法术新(18)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶毗舍童子",
			名称 = "搻兹",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机物理法术(13)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶蜃气妖",
			名称 = "奢比尸",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机法术新(18)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶真陀护法",
			名称 = "玄冥",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机物理法术(13)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶巨力神猿",
			名称 = "强良",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机物理法术(13)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶凤凰",
			名称 = "祝融",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机法术新(18)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶蛟龙",
			名称 = "共工",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机法术新(18)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶律法女娲",
			名称 = "蓐收",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机物理法术(13)
		},
		{
			愤怒 = 999,
			抗法修炼 = 20,
			气血 = 80000,
			魔法 = 100000,
			饰品 = true,
			灵力 = 5000,
			速度 = 100,
			攻击修炼 = 20,
			防御 = 100,
			防御修炼 = 20,
			法防 = 100,
			躲避 = 100,
			伤害 = 1000,
			法术修炼 = 20,
			模型 = "进阶吸血鬼",
			名称 = "天昊",
			等级 = 175,
			技能 = {
				"高级必杀",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 取随机物理法术(13)
		},
		阵法 = "天覆阵"
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:桃园野猪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 10
	战斗单位[1] = {
		愤怒 = 999,
		变异 = true,
		模型 = "野猪",
		名称 = "大野猪",
		等级 = 10,
		伤害 = 阶段属性[等级].伤害 * 0.45,
		气血 = 阶段属性[等级].气血 * 0.35,
		灵力 = 阶段属性[等级].法伤 * 0.5,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.05,
		法防 = 阶段属性[等级].法防 * 0.05,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"必杀",
			"法术暴击"
		},
		主动技能 = {
			"横扫千军",
			"烈火"
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			愤怒 = 999,
			模型 = "野猪",
			名称 = "野猪",
			等级 = 10,
			伤害 = 阶段属性[等级].伤害 * 0.4,
			气血 = 阶段属性[等级].气血 * 0.2,
			灵力 = 阶段属性[等级].法伤 * 0.45,
			速度 = 阶段属性[等级].速度 * 0.2,
			防御 = 阶段属性[等级].防御 * 0.01,
			法防 = 阶段属性[等级].法防 * 0.01,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"必杀",
				"法术暴击"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:桃园狸猫(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 10

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			模型 = "狸",
			名称 = "狸猫",
			等级 = 10,
			伤害 = 阶段属性[等级].伤害 * 0.25,
			气血 = 阶段属性[等级].气血 * 0.1,
			灵力 = 阶段属性[等级].法伤 * 0.2,
			速度 = 阶段属性[等级].速度 * 0.1,
			防御 = 阶段属性[等级].防御 * 0.01,
			法防 = 阶段属性[等级].法防 * 0.01,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"连击"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:商人的鬼魂(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 20
	战斗单位.阵法 = "天覆阵"
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		模型 = "野鬼",
		名称 = "商人的鬼魂",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 1.5,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"高级毒",
			"必杀",
			"连击",
			"高级鬼魂术",
			"理直气壮"
		},
		主动技能 = {}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		模型 = "虾兵",
		名称 = "虾兵喽罗",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 1,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"高级必杀"
		},
		主动技能 = {
			"壁垒击破",
			"惊心一剑"
		}
	}
	战斗单位[3] = {
		愤怒 = 9999,
		模型 = "蟹将",
		名称 = "蟹将喽罗",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 1,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"感知"
		},
		主动技能 = {
			"水攻",
			"靛沧海"
		}
	}
	战斗单位[4] = {
		愤怒 = 9999,
		模型 = "巨蛙",
		名称 = "巨蛙喽罗",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 1,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"法术暴击"
		},
		主动技能 = {
			"水攻",
			"推气过宫"
		}
	}
	战斗单位[5] = {
		愤怒 = 9999,
		模型 = "大海龟",
		名称 = "大海龟喽罗",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 1,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"高级再生"
		},
		主动技能 = {
			"金刚护体",
			"金刚护法",
			"牛刀小试"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:妖风战斗(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 30
	战斗单位[1] = {
		愤怒 = 9999,
		变异 = true,
		模型 = "吸血鬼",
		名称 = "妖风",
		等级 = 30,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 2,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级毒",
			"高级必杀",
			"高级连击",
			"理直气壮",
			"苍鸾怒击",
			"嗜血追击",
			"高级吸血"
		},
		主动技能 = {}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:酒肉和尚真(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 40
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "雨师",
		名称 = "酒肉和尚",
		等级 = 40,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 3,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠"
		}
	}
	等级 = 30

	for n = 2, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			模型 = "雨师",
			名称 = "酒肉和尚帮凶",
			等级 = 30,
			伤害 = 阶段属性[等级].伤害 * 0.8,
			气血 = 阶段属性[等级].气血 * 2.5,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术1(26)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:真刘洪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 65
	战斗单位[1] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = false,
		门派 = "大唐官府",
		模型 = "护卫",
		名称 = "刘洪",
		等级 = 65,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 5,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.4,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级必杀",
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"后发制人",
			"破釜沉舟",
			"斩龙诀"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = false,
		门派 = "阴曹地府",
		模型 = "强盗",
		名称 = "李彪",
		等级 = 65,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:日常商人鬼魂(任务id, 玩家id, 假人属性)
	local 战斗单位 = {
		{
			愤怒 = 9999,
			魔法 = 9999,
			不可封印 = true,
			气血 = 100000,
			法防 = 100,
			躲避 = 999,
			灵力 = 1000,
			伤害 = 4000,
			速度 = 800,
			模型 = "野鬼",
			名称 = "商人的鬼魂",
			等级 = 120,
			防御 = 800,
			技能 = {
				"高级毒",
				"高级必杀",
				"高级连击",
				"理直气壮",
				"高级感知",
				"高级鬼魂术"
			},
			主动技能 = {}
		},
		{
			愤怒 = 9999,
			魔法 = 9999,
			气血 = 100000,
			法防 = 100,
			躲避 = 999,
			灵力 = 1000,
			伤害 = 4000,
			速度 = 800,
			模型 = "虾兵",
			名称 = "虾兵喽罗",
			等级 = 120,
			防御 = 800,
			技能 = {
				"高级必杀",
				"高级感知"
			},
			主动技能 = {
				"壁垒击破",
				"惊心一剑",
				"破釜沉舟",
				"横扫千军",
				"高级鬼魂术"
			}
		},
		{
			愤怒 = 9999,
			魔法 = 9999,
			气血 = 100000,
			法防 = 100,
			躲避 = 999,
			灵力 = 3000,
			伤害 = 1000,
			速度 = 800,
			模型 = "蟹将",
			名称 = "蟹将喽罗",
			等级 = 120,
			防御 = 800,
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级感知",
				"高级鬼魂术"
			},
			主动技能 = {
				"水漫金山",
				"靛沧海"
			}
		},
		{
			愤怒 = 9999,
			魔法 = 9999,
			不可封印 = true,
			气血 = 100000,
			法防 = 100,
			躲避 = 999,
			灵力 = 3000,
			伤害 = 1000,
			速度 = 1000,
			模型 = "巨蛙",
			名称 = "巨蛙喽罗",
			等级 = 120,
			防御 = 800,
			技能 = {
				"高级法术连击",
				"高级感知"
			},
			主动技能 = {
				"水攻",
				"雷击",
				"落岩",
				"罗汉金钟",
				"推气过宫",
				"高级鬼魂术"
			}
		},
		{
			愤怒 = 9999,
			魔法 = 9999,
			气血 = 100000,
			法防 = 100,
			躲避 = 999,
			灵力 = 3000,
			伤害 = 1000,
			速度 = 1000,
			模型 = "大海龟",
			名称 = "大海龟喽罗",
			等级 = 120,
			防御 = 800,
			技能 = {
				"高级再生",
				"高级感知"
			},
			主动技能 = {
				"金刚护体",
				"金刚护法",
				"唧唧歪歪",
				"高级鬼魂术"
			}
		},
		阵法 = "天覆阵"
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:刻晴全服奖励(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 999,
			魔法 = 999999,
			不可封印 = true,
			气血 = 500000,
			变异 = true,
			法防 = 3000,
			躲避 = 999,
			灵力 = 300,
			伤害 = 300,
			速度 = 9999,
			模型 = "进阶蚩尤",
			名称 = "刻晴",
			等级 = 109,
			防御 = 2000,
			技能 = {},
			主动技能 = {
				"武神怒击",
				"刀光剑影",
				"毁灭之光"
			}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "程咬金",
			名称 = "程咬金",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级毒",
				"高级必杀",
				"高级连击",
				"理直气壮",
				"苍鸾怒击",
				"嗜血追击",
				"高级吸血"
			},
			主动技能 = {
				"横扫千军",
				"后发制人"
			}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 3000,
			速度 = 500,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "空度禅师",
			名称 = "空度禅师",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"唧唧歪歪"
			}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "东海龙王",
			名称 = "东海龙王",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"龙卷雨击",
				"龙腾",
				"二龙戏珠"
			},
			动技能 = {}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "二郎神",
			名称 = "二郎神",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"天崩地裂",
				"翻江搅海",
				"浪涌"
			},
			动技能 = {}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "镇元大仙",
			名称 = "镇元大仙",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级必杀",
				"高级连击",
				"理直气壮",
				"苍鸾怒击",
				"嗜血追击",
				"高级吸血"
			},
			主动技能 = {
				"烟雨剑法",
				"飘渺式"
			}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "牛魔王",
			名称 = "牛魔王",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"剑荡四方",
				"摇头摆尾"
			}
		},
		{
			不可封印 = true,
			愤怒 = 999,
			气血 = 100000,
			变异 = true,
			魔法 = 999999,
			饰品 = true,
			灵力 = 500,
			速度 = 700,
			防御 = 2000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 500,
			模型 = "大大王",
			名称 = "大大王",
			等级 = 89,
			奇经八脉 = {
				风刃妖风 = 1
			},
			技能 = {
				"高级感知",
				"高级必杀",
				"高级连击",
				"理直气壮",
				"苍鸾怒击",
				"嗜血追击",
				"高级吸血"
			},
			主动技能 = {
				"鹰击",
				"狮搏",
				"连环击"
			}
		},
		阵法 = "云垂阵"
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:妖风战斗日常(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 109
	战斗单位[1] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 100000,
		变异 = true,
		魔法 = 999999,
		饰品 = true,
		灵力 = 1000,
		速度 = 5000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 999,
		伤害 = 4000,
		模型 = "吸血鬼",
		名称 = "妖风",
		等级 = 109,
		奇经八脉 = {
			杀意 = 1,
			无敌 = 1,
			风刃 = 1,
			目空 = 1,
			干将 = 1,
			勇念 = 1,
			破军 = 1
		},
		技能 = {
			"高级强力",
			"高级必杀",
			"高级防御",
			"高级感知",
			"高级招架",
			"高级反击",
			"高级吸血",
			"高级驱鬼"
		},
		主动技能 = {
			"杀气诀",
			"横扫千军",
			"破釜沉舟",
			"破血狂攻",
			"壁垒击破",
			"命归术"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:白鹿精日常(任务id, 玩家id)
	local 战斗单位 = {
		{
			气血 = 100000,
			不可封印 = true,
			愤怒 = 999,
			变异 = true,
			魔法 = 999999,
			灵力 = 3000,
			速度 = 3000,
			防御 = 3000,
			法防 = 3000,
			躲避 = 999,
			伤害 = 3000,
			模型 = "赌徒",
			名称 = "白鹿精",
			等级 = 119,
			奇经八脉 = {
				威赫 = 1,
				电芒 = 1,
				月桂 = 1,
				雷波 = 1,
				画地为牢 = 1,
				怒气 = 1,
				神律 = 1
			},
			技能 = {
				"高级强力",
				"高级必杀",
				"高级防御",
				"高级感知",
				"高级招架",
				"高级反击",
				"高级吸血",
				"高级驱鬼"
			},
			主动技能 = {
				"天神护体",
				"天雷斩",
				"雷霆万钧",
				"弱点击破",
				"金刚镯"
			}
		},
		{
			愤怒 = 999,
			魔法 = 999999,
			不可封印 = true,
			气血 = 50000,
			法防 = 3000,
			躲避 = 999,
			灵力 = 3000,
			伤害 = 3000,
			速度 = 700,
			模型 = "狐狸精",
			名称 = "玉面狐狸",
			等级 = 119,
			防御 = 3000,
			奇经八脉 = {
				粘附 = 1,
				脱壳 = 1,
				迷梦 = 1,
				媚态 = 1,
				迷意 = 1,
				鼓乐 = 1,
				结阵 = 1,
				情劫 = 1
			},
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼",
				"高级感知"
			},
			主动技能 = {
				"命归术",
				"含情脉脉",
				"瘴气",
				"魔音摄魂",
				"盘丝阵",
				"幻镜术",
				"天罗地网"
			}
		}
	}

	for n = 3, 10 do
		战斗单位[n] = {
			魔法 = 9999,
			愤怒 = 9999,
			气血 = 30000,
			法防 = 2000,
			躲避 = 9999,
			灵力 = 2000,
			伤害 = 3000,
			速度 = 1000,
			模型 = "花妖",
			名称 = "花妖喽罗",
			等级 = 119,
			防御 = 3000,
			技能 = {
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼",
				"高级感知"
			},
			主动技能 = {
				"落叶萧萧",
				"碎甲符",
				"定身符",
				"失心符"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:酒肉日常(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 120
	战斗单位[1] = {
		气血 = 100000,
		不可封印 = true,
		愤怒 = 999,
		变异 = true,
		魔法 = 99999,
		灵力 = 3000,
		速度 = 1000,
		防御 = 5000,
		法防 = 5000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "雨师",
		名称 = "酒肉和尚",
		等级 = 120,
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级法术暴击",
			"高级法术连击",
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			魔法 = 99999,
			气血 = 100000,
			法防 = 5000,
			躲避 = 5000,
			灵力 = 2500,
			伤害 = 5000,
			速度 = 1000,
			模型 = "雨师",
			名称 = "酒肉和尚帮凶 ",
			等级 = 120,
			防御 = 5000,
			奇经八脉 = {
				诸天看护 = 1,
				舍利 = 1,
				心韧 = 1,
				佛显 = 1,
				映法 = 1,
				佛誉 = 1
			},
			技能 = {
				"高级法术暴击",
				"高级法术连击",
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"推气过宫",
				"金刚护体",
				"金刚护法",
				"唧唧歪歪"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:执法天兵日常(任务id, 玩家id)
	local 战斗单位 = {
		{
			气血 = 150000,
			不可封印 = true,
			愤怒 = 999,
			变异 = true,
			魔法 = 99999,
			灵力 = 5000,
			速度 = 1500,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 5000,
			模型 = "天兵",
			名称 = "执法天兵",
			等级 = 120,
			奇经八脉 = {
				怒气 = 1,
				雷波 = 1,
				画地为牢 = 1,
				威赫 = 1,
				神律 = 1
			},
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"天雷斩",
				"雷霆万钧"
			}
		},
		{
			气血 = 150000,
			不可封印 = true,
			愤怒 = 999,
			变异 = true,
			魔法 = 99999,
			灵力 = 3000,
			速度 = 1500,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 5000,
			模型 = "天兵",
			名称 = "守门天兵",
			等级 = 120,
			奇经八脉 = {
				破空 = 1,
				念心 = 1,
				风刃 = 1,
				无敌 = 1,
				干将 = 1,
				勇念 = 1,
				杀意 = 1,
				破军 = 1
			},
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"破釜沉舟",
				"横扫千军"
			}
		},
		{
			气血 = 150000,
			不可封印 = true,
			愤怒 = 999,
			变异 = true,
			魔法 = 99999,
			灵力 = 3000,
			速度 = 1500,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 5000,
			模型 = "天兵",
			名称 = " 守门天兵 ",
			等级 = 120,
			奇经八脉 = {
				鹰啸 = 1,
				化血 = 1,
				狮吼 = 1,
				威震 = 1,
				宁息 = 1
			},
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"鹰击",
				"狮搏"
			}
		},
		{
			愤怒 = 999,
			魔法 = 99999,
			气血 = 150000,
			变异 = true,
			法防 = 1000,
			躲避 = 5000,
			灵力 = 3000,
			伤害 = 5000,
			速度 = 2000,
			模型 = "天将",
			名称 = "守门天将",
			等级 = 120,
			防御 = 1000,
			技能 = {},
			主动技能 = {
				"天神护体",
				"天神护法",
				"碎玉弄影",
				"飞符炼魂",
				"一笑倾城"
			}
		},
		{
			愤怒 = 999,
			魔法 = 99999,
			气血 = 150000,
			变异 = true,
			法防 = 1000,
			躲避 = 5000,
			灵力 = 5000,
			伤害 = 5000,
			速度 = 2000,
			模型 = "天将",
			名称 = "守门天将 ",
			等级 = 120,
			防御 = 1000,
			技能 = {},
			主动技能 = {
				"推气过宫",
				"罗汉金钟",
				"圣灵之甲",
				"诸天看护"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天兵飞剑(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 100000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "凌波城",
		饰品 = true,
		灵力 = 100,
		速度 = 800,
		防御 = 800,
		法防 = 1,
		躲避 = 999,
		伤害 = 1600,
		模型 = "天兵",
		名称 = "天兵飞剑",
		等级 = 79,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级吸血",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"翻江搅海",
			"天崩地裂"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 50000,
		门派 = "龙宫",
		法防 = 1,
		躲避 = 999,
		灵力 = 1300,
		伤害 = 1500,
		速度 = 500,
		模型 = "蛟龙",
		名称 = "蛟龙喽啰",
		等级 = 79,
		防御 = 100,
		技能 = {
			"高级法术连击",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"水漫金山",
			"龙卷雨击",
			"龙腾"
		}
	}

	for n = 3, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			门派 = "天宫",
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "天兵",
			名称 = "天兵喽罗",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"天雷斩"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:假刘洪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 55
	战斗单位[1] = {
		愤怒 = 99999,
		门派 = "大唐官府",
		变异 = true,
		模型 = "护卫",
		名称 = "假刘洪",
		等级 = 55,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 7,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级必杀",
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			愤怒 = 9999,
			门派 = "大唐官府",
			模型 = "护卫",
			名称 = "衙役",
			等级 = 55,
			伤害 = 阶段属性[等级].伤害 * 0.8,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"高级必杀",
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"后发制人"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:蟹将军(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 65
	战斗单位[1] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = true,
		门派 = "龙宫",
		模型 = "蟹将",
		名称 = "蟹将军",
		等级 = 65,
		伤害 = 阶段属性[等级].伤害 * 1.3,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级感知"
		},
		主动技能 = {
			"龙卷雨击",
			"水漫金山",
			"罗汉金钟",
			"剑荡四方"
		}
	}
	等级 = 55

	for n = 2, 3 do
		战斗单位[n] = {
			不可封印 = true,
			愤怒 = 9999,
			门派 = "龙宫",
			模型 = "虾兵",
			名称 = "虾兵喽罗",
			等级 = 55,
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"高级必杀",
				"高级反击",
				"嗜血追击",
				"高级连击",
				"苍鸾怒击"
			},
			追加法术 = {
				{
					名称 = "横扫千军",
					概率 = 30,
					等级 = 175
				}
			},
			主动技能 = {}
		}
	end

	for n = 4, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			门派 = "方寸山",
			模型 = "蟹将",
			名称 = "蟹将喽罗",
			等级 = 55,
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {},
			主动技能 = {
				"失心符",
				"落雷符",
				"落魄符"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:幽冥鬼(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 60
	战斗单位[1] = {
		不可封印 = true,
		愤怒 = 99999,
		门派 = "阴曹地府",
		饰品 = true,
		模型 = "巡游天神",
		名称 = "幽冥鬼",
		等级 = 60,
		伤害 = 阶段属性[等级].伤害 * 1.3,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.4,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级鬼魂术",
			"高级吸血",
			"高级感知"
		},
		主动技能 = {
			"判官令",
			"阎罗令",
			"尸腐毒",
			"百爪狂杀"
		}
	}
	等级 = 50

	for n = 2, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			模型 = "僵尸",
			名称 = "僵尸喽罗",
			等级 = 50,
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {
				"鬼魂术",
				"高级反击",
				"高级反震",
				"高级吸血"
			},
			主动技能 = {
				"弱点击破",
				"破血狂攻",
				"尸腐毒"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:白琉璃(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 35
	战斗单位[1] = {
		愤怒 = 99999,
		饰品 = true,
		不可封印 = true,
		模型 = "星灵仙子",
		名称 = "白琉璃",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1.3,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"地涌金莲",
			"推气过宫",
			"生命之泉",
			"普渡众生"
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			模型 = "狐狸精",
			名称 = "狐狸精喽罗",
			等级 = 35,
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {},
			主动技能 = 取随机法术1(26)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:执法天兵(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 35
	战斗单位[1] = {
		愤怒 = 99999,
		门派 = "天宫",
		模型 = "天兵",
		名称 = "执法天兵",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1.3,
		气血 = 阶段属性[等级].气血 * 7,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"天雷斩",
			"天诛地灭",
			"镇妖"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		门派 = "大唐官府",
		模型 = "天兵",
		名称 = "守门天兵",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 4,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"破血狂攻",
			"破碎无双",
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[3] = {
		愤怒 = 9999,
		门派 = "狮驼岭",
		模型 = "天兵",
		名称 = " 守门天兵 ",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 4,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"鹰击",
			"连环击"
		}
	}
	战斗单位[4] = {
		愤怒 = 9999,
		门派 = "龙宫",
		模型 = "天将",
		名称 = "守门天将",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 4,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"龙腾",
			"龙卷雨击"
		}
	}
	战斗单位[5] = {
		愤怒 = 9999,
		门派 = "化生寺",
		模型 = "天将",
		名称 = "守门天将",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 4,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"达摩护体"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:酒肉和尚假(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 35
	战斗单位[1] = {
		愤怒 = 9999,
		门派 = "龙宫",
		模型 = "雨师",
		名称 = "酒肉和尚",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 4,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级魔之心",
			"高级法术波动",
			"高级法术暴击",
			"高级法术连击"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"神龙摆尾"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		门派 = "大唐官府",
		模型 = "赌徒",
		名称 = "赌徒喽罗",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 2,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级毒",
			"高级必杀",
			"高级连击",
			"理直气壮",
			"苍鸾怒击",
			"嗜血追击",
			"高级吸血"
		},
		主动技能 = {
			"后发制人",
			"反间之计",
			"横扫千军"
		}
	}
	战斗单位[3] = {
		愤怒 = 9999,
		门派 = "化生寺",
		模型 = "赌徒",
		名称 = "赌徒喽罗",
		等级 = 35,
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 2,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"金刚护体",
			"金刚护法"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:白鹿精(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 25
	战斗单位.阵法 = "龙飞阵"
	战斗单位[1] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "赌徒",
		名称 = "白鹿精",
		等级 = 30,
		伤害 = 阶段属性[等级].伤害 * 1.3,
		气血 = 阶段属性[等级].气血 * 2.5,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"反间之计",
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[2] = {
		愤怒 = 99999,
		模型 = "狐狸精",
		名称 = "玉面狐狸",
		等级 = 30,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 1.5,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.8,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		技能 = {
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"天罗地网",
			"含情脉脉",
			"勾魂"
		}
	}

	for n = 3, 10 do
		战斗单位[n] = {
			愤怒 = 99999,
			模型 = "花妖",
			名称 = "花妖喽罗",
			等级 = 30,
			伤害 = 阶段属性[等级].伤害 * 0.8,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			技能 = {},
			主动技能 = {
				"落岩",
				"推气过宫"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

local csbb = 100

function 战斗准备类:木桩伤害测试(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local aa = {}

	if 单机设置 then
		aa = {
			"测试大肉盾",
			"龙龟"
		}
	else
		aa = {
			"龙龟",
			"龙马"
		}
	end

	for n = 1, 10 do
		战斗单位[n] = {
			伤害 = 1,
			魔法 = 99999,
			愤怒 = 0,
			气血 = 99999999,
			法防 = 0,
			躲避 = 1,
			灵力 = 1,
			显示饰品 = true,
			速度 = 1,
			模型 = "龙龟",
			不攻击 = 1,
			防御 = 0,
			名称 = "木桩" .. n,
			等级 = 等级,
			技能 = {
				"高级神佑复生",
				"出其不意",
				"高级魔法反击",
				"高级反击"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:押镖遇怪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级

	for n = 1, 2 do
		战斗单位[n] = {
			愤怒 = 9999,
			模型 = "强盗",
			名称 = "强盗",
			伤害 = 阶段属性[等级].伤害 * 0.7,
			气血 = 阶段属性[等级].气血 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 0.7,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = {
				"高级连击",
				"高级必杀"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取赵云信息(任务id, 玩家id)
	local 等级 = 120
	local 模型 = "龙太子"
	local 武器造型 = {
		级别 = 160,
		武器 = "弑皇"
	}
	local 战斗单位 = {}
	local 难度系数 = 1.2
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		角色 = true,
		变异 = false,
		显示饰品 = false,
		染色方案 = 3,
		武器染色方案 = 20113,
		名称 = "赵云",
		模型 = 模型,
		染色组 = {
			3,
			6,
			6,
			序号 = 3710
		},
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		武器染色组 = {
			[1.0] = 1,
			[2.0] = 0
		},
		伤害 = 阶段属性[等级].伤害 * 2 * 难度系数,
		气血 = 阶段属性[等级].气血 * 10 * 难度系数,
		灵力 = 阶段属性[等级].法伤 * 1.6 * 难度系数,
		速度 = 阶段属性[等级].速度 * 1 * 难度系数,
		防御 = 阶段属性[等级].防御 * 0.5 * 难度系数,
		法防 = 阶段属性[等级].法防 * 0.3 * 难度系数,
		躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型名称范围 = {
		"亲兵"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 10)]
		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			愤怒 = 99999,
			角色 = true,
			名称 = "上将亲兵",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			伤害 = 阶段属性[等级].伤害 * 1.2 * 难度系数,
			气血 = 阶段属性[等级].气血 * 8 * 难度系数,
			灵力 = 阶段属性[等级].法伤 * 1 * 难度系数,
			速度 = 阶段属性[等级].速度 * 0.5 * 难度系数,
			防御 = 阶段属性[等级].防御 * 0.3 * 难度系数,
			法防 = 阶段属性[等级].法防 * 0.8 * 难度系数,
			躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取关羽信息(任务id, 玩家id)
	local 等级 = 120
	local 模型 = "巨魔王"
	local 武器造型 = {
		级别 = 160,
		武器 = "裂天"
	}
	local 战斗单位 = {}
	local 难度系数 = 1.1
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		角色 = true,
		变异 = false,
		显示饰品 = false,
		染色方案 = 5,
		武器染色方案 = 20113,
		名称 = "关羽",
		模型 = 模型,
		染色组 = {
			5,
			5,
			5,
			序号 = 3710
		},
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		武器染色组 = {
			[1.0] = 1,
			[2.0] = 0
		},
		伤害 = 阶段属性[等级].伤害 * 2 * 难度系数,
		气血 = 阶段属性[等级].气血 * 10 * 难度系数,
		灵力 = 阶段属性[等级].法伤 * 1.6 * 难度系数,
		速度 = 阶段属性[等级].速度 * 1 * 难度系数,
		防御 = 阶段属性[等级].防御 * 0.5 * 难度系数,
		法防 = 阶段属性[等级].法防 * 0.3 * 难度系数,
		躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型名称范围 = {
		"亲兵"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 10)]
		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			愤怒 = 99999,
			角色 = true,
			名称 = "上将亲兵",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			伤害 = 阶段属性[等级].伤害 * 1.2 * 难度系数,
			气血 = 阶段属性[等级].气血 * 8 * 难度系数,
			灵力 = 阶段属性[等级].法伤 * 1 * 难度系数,
			速度 = 阶段属性[等级].速度 * 0.5 * 难度系数,
			防御 = 阶段属性[等级].防御 * 0.3 * 难度系数,
			法防 = 阶段属性[等级].法防 * 0.8 * 难度系数,
			躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取张飞信息(任务id, 玩家id)
	local 等级 = 120
	local 模型 = "龙太子"
	local 武器造型 = {
		级别 = 120,
		武器 = "飞龙在天"
	}
	local 战斗单位 = {}
	local 难度系数 = 1
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		角色 = true,
		变异 = false,
		显示饰品 = false,
		染色方案 = 3,
		武器染色方案 = 20113,
		名称 = "张飞",
		模型 = 模型,
		染色组 = {
			3,
			6,
			6,
			序号 = 3710
		},
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		武器染色组 = {
			[1.0] = 1,
			[2.0] = 0
		},
		伤害 = 阶段属性[等级].伤害 * 2 * 难度系数,
		气血 = 阶段属性[等级].气血 * 10 * 难度系数,
		灵力 = 阶段属性[等级].法伤 * 1.6 * 难度系数,
		速度 = 阶段属性[等级].速度 * 1 * 难度系数,
		防御 = 阶段属性[等级].防御 * 0.5 * 难度系数,
		法防 = 阶段属性[等级].法防 * 0.3 * 难度系数,
		躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型名称范围 = {
		"亲兵"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 10)]
		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			愤怒 = 99999,
			角色 = true,
			名称 = "上将亲兵",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			伤害 = 阶段属性[等级].伤害 * 1.2 * 难度系数,
			气血 = 阶段属性[等级].气血 * 8 * 难度系数,
			灵力 = 阶段属性[等级].法伤 * 1 * 难度系数,
			速度 = 阶段属性[等级].速度 * 0.5 * 难度系数,
			防御 = 阶段属性[等级].防御 * 0.3 * 难度系数,
			法防 = 阶段属性[等级].法防 * 0.8 * 难度系数,
			躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取黄忠信息(任务id, 玩家id)
	local 等级 = 120
	local 模型 = "羽灵神"
	local 武器造型 = {
		级别 = 160,
		武器 = "若木"
	}
	local 战斗单位 = {}
	local 难度系数 = 0.9
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		角色 = true,
		变异 = false,
		显示饰品 = false,
		染色方案 = 1,
		武器染色方案 = 20113,
		名称 = "黄忠",
		模型 = 模型,
		染色组 = {
			2,
			5,
			5,
			序号 = 3710
		},
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		武器染色组 = {
			[1.0] = 1,
			[2.0] = 0
		},
		伤害 = 阶段属性[等级].伤害 * 2 * 难度系数,
		气血 = 阶段属性[等级].气血 * 10 * 难度系数,
		灵力 = 阶段属性[等级].法伤 * 1.6 * 难度系数,
		速度 = 阶段属性[等级].速度 * 1 * 难度系数,
		防御 = 阶段属性[等级].防御 * 0.5 * 难度系数,
		法防 = 阶段属性[等级].法防 * 0.3 * 难度系数,
		躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型名称范围 = {
		"亲兵"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 10)]
		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			愤怒 = 99999,
			角色 = true,
			名称 = "上将亲兵",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			伤害 = 阶段属性[等级].伤害 * 1.2 * 难度系数,
			气血 = 阶段属性[等级].气血 * 8 * 难度系数,
			灵力 = 阶段属性[等级].法伤 * 1 * 难度系数,
			速度 = 阶段属性[等级].速度 * 0.5 * 难度系数,
			防御 = 阶段属性[等级].防御 * 0.3 * 难度系数,
			法防 = 阶段属性[等级].法防 * 0.8 * 难度系数,
			躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取马超信息(任务id, 玩家id)
	local 等级 = 120
	local 模型 = "逍遥生"
	local 武器造型 = {
		级别 = 160,
		武器 = "擒龙"
	}
	local 战斗单位 = {}
	local 难度系数 = 0.8
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		角色 = true,
		变异 = false,
		显示饰品 = false,
		染色方案 = 1,
		武器染色方案 = 20113,
		名称 = "马超",
		模型 = 模型,
		染色组 = {
			5,
			3,
			5,
			序号 = 3710
		},
		武器 = 取武器数据(武器造型.武器, 武器造型.级别),
		武器染色组 = {
			[1.0] = 1,
			[2.0] = 0
		},
		伤害 = 阶段属性[等级].伤害 * 2 * 难度系数,
		气血 = 阶段属性[等级].气血 * 10 * 难度系数,
		灵力 = 阶段属性[等级].法伤 * 1.6 * 难度系数,
		速度 = 阶段属性[等级].速度 * 1 * 难度系数,
		防御 = 阶段属性[等级].防御 * 0.5 * 难度系数,
		法防 = 阶段属性[等级].法防 * 0.3 * 难度系数,
		躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型名称范围 = {
		"亲兵"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 10)]
		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			愤怒 = 99999,
			角色 = true,
			名称 = "上将亲兵",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			伤害 = 阶段属性[等级].伤害 * 1.2 * 难度系数,
			气血 = 阶段属性[等级].气血 * 8 * 难度系数,
			灵力 = 阶段属性[等级].法伤 * 1 * 难度系数,
			速度 = 阶段属性[等级].速度 * 0.5 * 难度系数,
			防御 = 阶段属性[等级].防御 * 0.3 * 难度系数,
			法防 = 阶段属性[等级].法防 * 0.8 * 难度系数,
			躲避 = 阶段属性[等级].躲避 / 2 * 难度系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取毛贼信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	local 模型范围 = {
		"山贼",
		"赌徒",
		"强盗"
	}
	local 怪物名称 = {
		{
			"毛贼",
			"强盗",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"凶兽",
			"老虎",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"打手",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"打手",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"打手",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"打手",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.6,
				灵力 = 阶段属性[等级].法伤 * 0.7,
				速度 = 阶段属性[等级].速度 * 0.5,
				防御 = 阶段属性[等级].防御 * 0.05,
				法防 = 阶段属性[等级].法防 * 0.05,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取销赃贼信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 模型范围 = {
		"山贼",
		"赌徒",
		"强盗"
	}
	local 怪物名称 = {
		{
			"销赃贼",
			"吸血鬼",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"凶兽",
			"老虎",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"飞贼喽罗",
			模型范围[取随机数(1, #模型范围)],
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"飞贼喽罗",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"飞贼喽罗",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"飞贼喽罗",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.9,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.7,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.7,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取宝贼信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 2
	local 模型范围 = {
		"天将",
		"天兵"
	}
	local 怪物名称 = {
		{
			"宝贼",
			"夜罗刹",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"飞贼部将",
			"吸血鬼",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"凶兽",
			"噬天虎",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"飞贼部将",
			"地狱战神",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"飞贼部将",
			"鼠先锋",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"飞贼护卫",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"飞贼护卫",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}
	local 可选 = {
		7,
		4,
		5,
		6
	}
	位置 = {
		[5] = 夜光随机法术,
		[6] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.9,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.7,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取盗贼首领信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	local 模型范围 = {
		"白熊",
		"兔子怪",
		"蛟龙",
		"凤凰",
		"古代瑞兽"
	}
	local 怪物名称 = {
		{
			"盗贼首领",
			"雨师",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"飞贼骨干",
			"夜罗刹",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"异兽",
			"虬龙",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"神秘刺客",
			"夜罗刹",
			{
				"高级连击",
				"高级必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"飞贼骨干",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"飞贼骨干",
			模型范围[取随机数(1, #模型范围)],
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"飞贼骨干",
			模型范围[取随机数(1, #模型范围)],
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}
	local 可选 = {
		7,
		4,
		5,
		6
	}
	位置 = {
		[5] = 夜光随机法术,
		[6] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.2,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.9,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.75,
				灵力 = 阶段属性[等级].法伤 * 0.85,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取皇宫贼王信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 10
	local 模型范围 = {
		"牛头",
		"马面",
		"野鬼",
		"黑山老妖"
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级夜战",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"盗贼头领",
			"夜罗刹",
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"死士",
			"幽灵",
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"僵尸护卫",
			"僵尸",
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"孤魂野鬼",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术连击",
				"夜战",
				"高级法术暴击",
				"高级法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"孤魂野鬼",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级必杀",
				"高级夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"孤魂野鬼",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术连击",
				"高级敏捷",
				"高级法术暴击",
				"高级法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}
	local 可选 = {
		7,
		4,
		5,
		6
	}
	位置 = {
		[5] = 夜光随机法术,
		[6] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.1,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.4,
				法防 = 阶段属性[等级].法防 * 0.6,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.9,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.3,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取江湖大盗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			"江湖骗子",
			"护卫",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"恍然",
			"狂豹人形",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"蛊惑",
			"幽灵",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{
				伤害 = 1.1
			},
			{}
		},
		{
			"色诱",
			"夜罗刹",
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"难辨",
			"龙龟",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		}
	}

	for n = 1, 5 do
		local i = n

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				饰品 = true,
				变异 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.6,
				灵力 = 阶段属性[等级].法伤 * 0.7,
				速度 = 阶段属性[等级].速度 * 0.5,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派乾坤袋信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		躲避 = 100,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 12,
		气血 = qz(等级 * 等级),
		灵力 = 等级 * 5,
		速度 = 等级 * 3,
		防御 = 等级 * 6,
		法防 = 等级 * 1.2,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取60级世界BOSS信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 70
	local 随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	战斗单位.阵法 = 随机阵法[取随机数(1, #随机阵法)]
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		名称 = "万年老妖",
		模型 = 任务数据[任务id].模型,
		伤害 = 阶段属性[等级].伤害 * 2,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.5,
		法防 = 阶段属性[等级].法防 * 0.8,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶黑山老妖",
		名称 = "千年老妖",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.4,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"横扫千军",
			"天雷斩",
			"浪涌"
		}
	}
	战斗单位[3] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶黑山老妖",
		名称 = "千年老妖",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"三昧真火",
			"龙卷雨击",
			"飞砂走石"
		}
	}
	战斗单位[4] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "黑山老妖",
		名称 = "老妖亲卫",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[5] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "黑山老妖",
		名称 = "老妖亲卫",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[6] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶锦毛貂精",
		名称 = "老妖亲兵",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"龙卷雨击",
			"飞砂走石"
		}
	}
	战斗单位[7] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶千年蛇魅",
		名称 = "老妖亲兵",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 2.5,
		速度 = 阶段属性[等级].速度 * 1.3,
		防御 = 阶段属性[等级].防御 * 0.5,
		法防 = 阶段属性[等级].法防 * 0.7,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"推气过宫",
			"晶清诀",
			"罗汉金钟",
			"圣灵之甲",
			"四海升平"
		}
	}
	战斗单位[8] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶碧水夜叉",
		名称 = "老妖亲兵",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.4,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"神佑复生"
		},
		主动技能 = {
			"横扫千军",
			"天雷斩",
			"浪涌"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取100级世界BOSS信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 110
	local 随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	战斗单位.阵法 = 随机阵法[取随机数(1, #随机阵法)]
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		名称 = "万年鬼王",
		模型 = 任务数据[任务id].模型,
		伤害 = 阶段属性[等级].伤害 * 2,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.7,
		法防 = 阶段属性[等级].法防 * 1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "鬼将",
		名称 = "千年妖王",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.4,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[3] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "鬼将",
		名称 = "千年妖王",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.4,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[4] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶幽萤娃娃",
		名称 = "鬼王侍女",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[5] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶幽萤娃娃",
		名称 = "鬼王侍女",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[6] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶画魂",
		名称 = "鬼族先锋",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[7] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶阴阳伞",
		名称 = "鬼族先锋",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计",
			"晶清诀",
			"四海升平"
		}
	}
	战斗单位[8] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶阴阳伞",
		名称 = "鬼族先锋",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[9] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶幽灵",
		名称 = "鬼族圣贤",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 2.5,
		速度 = 阶段属性[等级].速度 * 1.3,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.8,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"罗汉金钟",
			"晶清诀"
		}
	}
	战斗单位[10] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		模型 = "进阶吸血鬼",
		名称 = "鬼族先锋",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.4,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取150级世界BOSS信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 160
	战斗单位[1] = {
		愤怒 = 99999,
		不可封印 = true,
		变异 = true,
		名称 = "罗刹王",
		模型 = 任务数据[任务id].模型,
		模型 = 任务数据[任务id].模型,
		伤害 = 阶段属性[等级].伤害 * 2,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.7,
		法防 = 阶段属性[等级].法防 * 1,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶大力金刚",
		名称 = "大力神王",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.7,
		法防 = 阶段属性[等级].法防 * 0.8,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶大力金刚",
		名称 = "大力神王",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.7,
		法防 = 阶段属性[等级].法防 * 0.8,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶炎魔神",
		名称 = "狂暴法神",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.9,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶炎魔神",
		名称 = "狂暴法神",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.9,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[6] = {
		不可封印 = true,
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶混沌兽",
		名称 = "玄法无边",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.9,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[7] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶琴仙",
		名称 = "神封无量",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[8] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶琴仙",
		名称 = "神封无量",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1.3,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.6,
		法防 = 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[9] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶龙龟",
		名称 = "长生无界",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 2.5,
		速度 = 阶段属性[等级].速度 * 1.3,
		防御 = 阶段属性[等级].防御 * 0.9,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"金刚护法",
			"罗汉金钟",
			"唧唧歪歪"
		}
	}
	战斗单位[10] = {
		愤怒 = 99999,
		变异 = true,
		模型 = "进阶蜃气妖",
		名称 = "力破乾坤",
		伤害 = 阶段属性[等级].伤害 * 1.2,
		气血 = 阶段属性[等级].气血 * 6,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.7,
		法防 = 阶段属性[等级].法防 * 0.8,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级驱鬼",
			"高级感知",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派示威信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		角色 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.7,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[任务数据[任务id].门派]
	}
	local 模型 = 取随机怪(30, 等级)
	战斗单位[2] = {
		角色 = true,
		名称 = "帮凶",
		模型 = 模型[2],
		伤害 = 等级 * 8,
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.7,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派支援信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 模型范围 = {
		"人",
		"魔",
		"仙"
	}

	if 玩家数据[玩家id].角色.数据.种族 == "人" then
		模型范围 = {
			"魔",
			"仙"
		}
	elseif 玩家数据[玩家id].角色.数据.种族 == "魔" then
		模型范围 = {
			"人",
			"仙"
		}
	elseif 玩家数据[玩家id].角色.数据.种族 == "仙" then
		模型范围 = {
			"魔",
			"人"
		}
	end

	模型范围 = 模型范围[取随机数(1, 2)]
	local 模型 = ""

	if 模型范围 == "人" then
		模型 = Q_随机模型[取随机数(1, 5)]
	elseif 模型范围 == "仙" then
		模型 = Q_随机模型[取随机数(6, 10)]
	elseif 模型范围 == "魔" then
		模型 = Q_随机模型[取随机数(11, 15)]
	end

	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	战斗单位[1] = {
		不可封印 = true,
		角色 = true,
		魔法 = 99999900,
		速度 = 0,
		躲避 = 100,
		伤害 = 0,
		名称 = "敌人",
		模型 = 模型,
		气血 = qz(等级 * 60),
		灵力 = 等级 * 4,
		防御 = 等级 * 4,
		法防 = 等级 * 1.5,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		主动技能 = {}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派闯关信息(任务id, 玩家id)
	local 任务id1 = 玩家数据[玩家id].角色:取任务(107)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 9999,
		角色 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		武器 = 取武器数据(Q_闯关数据[Q_门派编号[任务数据[任务id].序列]].武器.名称, 120),
		气血 = 阶段属性[等级].气血 * 1.2,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 1.15,
		灵力 = 阶段属性[等级].法伤 * 1.2,
		速度 = 阶段属性[等级].速度 * 1.3,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术1[Q_门派编号[任务数据[任务id].序列]]
	}
	local 数量 = 6 + 15 - #任务数据[任务id1].闯关序列

	if 数量 > 10 then
		数量 = 10
	end

	for n = 2, 数量 do
		local aa = Q_门派法术1[Q_门派编号[任务数据[任务id].序列]]

		if ygsj() <= 20 then
			aa = {}
		end

		战斗单位[n] = {
			愤怒 = 9999,
			名称 = Q_门派编号[任务数据[任务id].序列] .. "弟子",
			模型 = Q_闯关数据[Q_门派编号[任务数据[任务id].序列]].弟子[取随机数(1, #Q_闯关数据[Q_门派编号[任务数据[任务id].序列]].弟子)],
			气血 = 阶段属性[等级].气血 * 0.8,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.85,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.15,
			法防 = 阶段属性[等级].法防 * 0.15,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = aa
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取幼儿园信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 0
	local 模型 = 取随机怪(135, 145)
	模型 = 模型[2]

	for n = 1, 1 do
		战斗单位[n] = {
			魔法 = 99999900,
			气血 = 5000,
			变异 = true,
			躲避 = 0,
			伤害 = 100,
			速度 = 0,
			名称 = 模型 .. "宝宝",
			模型 = 模型,
			灵力 = 等级 * 4,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取幼儿园信息1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 0
	local 模型 = 取随机怪(155, 175)
	模型 = 模型[2]

	for n = 1, 1 do
		战斗单位[n] = {
			魔法 = 99999900,
			气血 = 5000,
			变异 = true,
			躲避 = 0,
			伤害 = 100,
			速度 = 0,
			名称 = 模型 .. "宝宝",
			模型 = 模型,
			灵力 = 等级 * 4,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

特殊神兽列表 = {
	鲲鹏 = 1,
	癸卯神兔 = 1,
	超级红孩儿 = 1,
	超级离火兽 = 1,
	超级飞廉 = 1,
	逍遥神牛 = 1
}
神兽模型范围 = {
	"超级神龙",
	"超级孔雀",
	"超级灵狐",
	"超级麒麟",
	"超级大鹏",
	"超级白泽",
	"超级灵鹿",
	"超级大象",
	"超级金猴",
	"超级大熊猫",
	"超级泡泡",
	"超级神兔",
	"超级神牛",
	"超级海豚",
	"超级人参娃娃",
	"超级青鸾",
	"超级腾蛇",
	"超级六耳猕猴",
	"超级神羊",
	"超级土地公公",
	"超级神猴",
	"超级玉兔",
	"超级神鸡",
	"超级筋斗云",
	"超级神蛇",
	"超级神鼠",
	"超级猪小戒",
	"神兽小龙人",
	"神兽雪精灵",
	"神兽时光叽",
	"神兽百灵羊",
	"神兽孙小圣",
	"兔乖乖",
	"齐天小圣",
	"辛丑神牛",
	"超级神柚",
	"超级飞廉",
	"超级离火兽",
	"超级有熊",
	"仙兽翼龙",
	"壬寅神虎",
	"超级神虎",
	"超级小白龙",
	"超级赤焰兽",
	"超级神龙",
	"超级孔雀",
	"超级灵狐",
	"超级麒麟",
	"超级大鹏",
	"超级白泽",
	"超级灵鹿",
	"超级大象",
	"超级金猴",
	"超级大熊猫",
	"超级泡泡",
	"超级神兔",
	"超级神牛",
	"超级海豚",
	"超级人参娃娃",
	"超级青鸾",
	"超级腾蛇",
	"超级六耳猕猴",
	"超级神羊",
	"超级土地公公",
	"超级神猴",
	"超级玉兔",
	"超级神鸡",
	"超级筋斗云",
	"超级神蛇",
	"超级神鼠",
	"超级猪小戒",
	"神兽小龙人",
	"神兽雪精灵",
	"神兽时光叽",
	"神兽百灵羊",
	"神兽孙小圣",
	"兔乖乖",
	"齐天小圣",
	"辛丑神牛",
	"超级神柚",
	"超级红孩儿",
	"鲲鹏",
	"仙兽翼龙",
	"壬寅神虎",
	"超级神虎",
	"超级小白龙",
	"超级赤焰兽",
	"逍遥神牛",
	"癸卯神兔",
	"甲辰神龙",
	"超级神龙",
	"超级孔雀",
	"超级灵狐",
	"超级麒麟",
	"超级大鹏",
	"超级白泽",
	"超级灵鹿",
	"超级大象",
	"超级金猴",
	"超级大熊猫",
	"超级泡泡",
	"超级神兔",
	"超级神牛",
	"超级海豚",
	"超级人参娃娃",
	"超级青鸾",
	"超级腾蛇",
	"超级六耳猕猴",
	"超级神羊",
	"超级土地公公",
	"超级神猴",
	"超级玉兔",
	"超级神鸡",
	"超级筋斗云",
	"超级神蛇",
	"超级神鼠",
	"超级猪小戒",
	"神兽小龙人",
	"神兽雪精灵",
	"神兽时光叽",
	"神兽百灵羊",
	"神兽孙小圣",
	"兔乖乖",
	"齐天小圣",
	"辛丑神牛",
	"超级神柚"
}

function 战斗准备类:随机神兽(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 0
	local 模型 = 神兽模型范围[ygsj(#神兽模型范围)]

	for n = 1, 1 do
		战斗单位[n] = {
			门派 = "神兽",
			魔法 = 99999900,
			气血 = 10000,
			变异 = false,
			躲避 = 0,
			伤害 = 100,
			速度 = 10000,
			名称 = 模型,
			模型 = 模型,
			灵力 = 等级 * 4,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取封妖任务信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 1.1,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1.1,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	local 数量 = 取队伍人数(玩家id)
	数量 = 数量 + 3
	local 等级 = 取平均阶段等级(玩家id)

	for n = 1, 数量 do
		local 模型 = 取随机怪(任务数据[任务id].等级, 任务数据[任务id].等级)
		战斗单位[n + 1] = {
			名称 = 模型[2] .. "喽罗",
			模型 = 模型[2],
			伤害 = 阶段属性[等级].伤害 * 0.75,
			气血 = 阶段属性[等级].气血 * 0.8,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.4,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(2)
		}
	end

	if 取随机数() <= 30 then
		战斗单位[#战斗单位].变异 = true
		战斗单位[#战斗单位].名称 = "变异" .. 战斗单位[#战斗单位].模型
		战斗单位[#战斗单位].主动技能 = {
			"失心符"
		}
		战斗单位[#战斗单位].伤害 = 1
		战斗单位[#战斗单位].法防 = 等级 * 0.5
		战斗单位[#战斗单位].速度 = 等级 * 50
		战斗单位[#战斗单位].气血 = 战斗单位[#战斗单位].气血 * 10
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取官职巡逻信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	for n = 1, 2 do
		战斗单位[n] = {
			模型 = "强盗",
			名称 = "突厥奸细",
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.8,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派巡逻信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5

	for n = 1, 2 do
		local 模型 = 取随机怪(1, 等级)
		战斗单位[n] = {
			名称 = "捣乱的" .. 模型[2],
			模型 = 模型[2],
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.05,
			法防 = 阶段属性[等级].法防 * 0.05,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	战斗单位[2].名称 = 战斗单位[2].模型 .. "帮凶"

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取青龙巡逻信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	for n = 1, 2 do
		local 模型 = 取随机怪(1, 等级)
		战斗单位[n] = {
			名称 = "捣乱的" .. 模型[2],
			模型 = 模型[2],
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.7,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	战斗单位[2].名称 = 战斗单位[2].模型 .. "帮凶"

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取玄武巡逻信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	for n = 1, 2 + 取队伍人数(玩家id) + ygsj(3) do
		local 模型 = 取随机怪(1, 等级)
		战斗单位[n] = {
			名称 = "捣乱的" .. 模型[2],
			模型 = 模型[2],
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.7,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	战斗单位[2].名称 = 战斗单位[2].模型 .. "帮凶"

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取官职流氓信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5

	for n = 1, 2 do
		战斗单位[n] = {
			模型 = "赌徒",
			名称 = "闹事的流氓",
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 0.9,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知",
				"夜战",
				"必杀",
				"法术连击",
				"法术暴击"
			},
			主动技能 = 取随机法术(3)
		}
	end

	战斗单位[2].名称 = "流氓同伙"
	战斗单位[2].变异 = true
	战斗单位[1].主动技能 = {}
	战斗单位[1].气血 = 阶段属性[等级].气血 * 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取三界悬赏令信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	local 模型范围 = {
		"山贼",
		"狐狸精",
		"马面",
		"凤凰",
		"骷髅怪",
		"鬼将",
		"百足将军"
	}
	local 怪物名称 = {
		{
			"通缉犯",
			"强盗",
			{
				"高级感知",
				"高级夜战",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{
				伤害 = 1.2
			},
			{}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级连击",
				"高级必杀",
				"高级夜战"
			},
			{
				伤害 = 1.2
			},
			{}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术连击",
				"夜战",
				"高级法术暴击",
				"高级法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级必杀",
				"高级夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术连击",
				"高级敏捷",
				"高级法术暴击",
				"高级法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"帮凶",
			模型范围[取随机数(1, #模型范围)],
			{
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		5,
		4,
		7
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[7] = 夜光随机封印法术
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.1,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.5,
				法防 = 阶段属性[等级].法防 * 0.7,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.9,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 0.65,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.5,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取游泳水妖信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 模型范围 = {
		"蟹将",
		"虾兵",
		"大海龟",
		"海毛虫",
		"巨蛙",
		"海星",
		"章鱼",
		"小龙女",
		"蛟龙",
		"龟丞相"
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	local 数量 = 2 + 取队伍人数(玩家id)

	for n = 1, 数量 do
		local 模型 = 模型范围[取随机数(1, #模型范围)]
		战斗单位[n] = {
			名称 = "捣乱的水妖",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.7,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 10
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		local 随机技能 = "高级必杀"
		local 模型 = "鬼将"

		if 取随机数() <= 50 then
			随机技能 = "高级连击"
			模型 = "幽灵"
		end

		战斗单位[n] = {
			名称 = "劫匪",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 0.7 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.7 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 0.7 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.65 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.2 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.2 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				随机技能
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 10
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		local 随机技能 = {
			"三昧真火",
			"烈火"
		}
		local 模型 = "炎魔神"
		local 被动技能 = {
			"高级法术暴击"
		}

		if 取随机数() <= 20 then
			随机技能 = {
				"龙卷雨击",
				"龙吟"
			}
			模型 = "混沌兽"
			被动技能 = {
				"高级法术连击"
			}
		elseif 取随机数() <= 50 then
			随机技能 = {
				"唧唧歪歪",
				"落雷符"
			}
			模型 = "灵符女娲"
			被动技能 = {
				"高级法术波动"
			}
		elseif 取随机数() <= 70 then
			随机技能 = {
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			}
			被动技能 = {
				"高级法术波动"
			}
		end

		战斗单位[n] = {
			名称 = "劫匪",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 0.8 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.8 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 0.8 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.7 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.2 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.2 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = 被动技能,
			主动技能 = 随机技能
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 8
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		战斗单位[n] = {
			模型 = "雾中仙",
			名称 = "劫匪",
			伤害 = 阶段属性[等级].伤害 * 0.9 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.9 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 0.9 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.75 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.3 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.3 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级隐身"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 8
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		local 模型 = "曼珠沙华"
		local 主动技能 = 取随机法术(3)

		if 数量 > 4 then
			模型 = "修罗傀儡妖"
			主动技能 = {
				"烟雨剑法"
			}
		end

		战斗单位[n] = {
			名称 = "劫匪",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 0.9 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.9 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 0.9 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.75 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.3 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.3 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级鬼魂术"
			},
			主动技能 = 主动技能
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息5(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 3
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		local 模型 = "蜃气妖"
		local 主动技能 = {
			"横扫千军"
		}

		if n == 2 then
			模型 = "长眉灵猴"
			主动技能 = {
				"龙卷雨击"
			}
		elseif n == 3 then
			模型 = "狂豹人形"
			主动技能 = {
				"烟雨剑法"
			}
		end

		战斗单位[n] = {
			名称 = "劫匪",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 1 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.9 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 1 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.75 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.3 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.3 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 主动技能
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取镖王信息6(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 10
	local 难度 = 任务数据[任务id].难度
	local 血量加成 = 1
	local 伤害加成 = 1
	local 灵力加成 = 1
	local 防御加成 = 1
	local 速度加成 = 1
	local 法防加成 = 1

	if 难度 == "高级" then
		血量加成 = 1.1
		伤害加成 = 1.1
		灵力加成 = 1.1
		防御加成 = 1.1
		速度加成 = 1.1
		法防加成 = 1.1
	elseif 难度 == "珍贵" then
		血量加成 = 1.2
		伤害加成 = 1.2
		灵力加成 = 1.2
		防御加成 = 1.2
		速度加成 = 1.2
		法防加成 = 1.2
	end

	for n = 1, 数量 do
		local 模型 = 取随机怪(40, 120)
		战斗单位[n] = {
			名称 = "劫匪",
			模型 = 模型[2],
			伤害 = 阶段属性[等级].伤害 * 0.9 * 伤害加成,
			气血 = 阶段属性[等级].气血 * 0.9 * 血量加成,
			灵力 = 阶段属性[等级].法伤 * 0.9 * 灵力加成,
			速度 = 阶段属性[等级].速度 * 0.75 * 速度加成,
			防御 = 阶段属性[等级].防御 * 0.3 * 防御加成,
			法防 = 阶段属性[等级].法防 * 0.3 * 法防加成,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取妖魔鬼怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 技能 = {
		"鬼魂术",
		"高级防御",
		"高级健壮",
		"幸运"
	}
	local 气血 = 1.7

	if 任务数据[任务id].名称 == "妖魔" then
		技能 = {
			"神佑复生",
			"防御",
			"敏捷"
		}
		气血 = 1
	end

	战斗单位[1] = {
		愤怒 = 9999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		气血 = 阶段属性[等级].气血 * 0.6 * 气血,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 0.7,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		等级 = 等级,
		技能 = 技能,
		主动技能 = 夜光随机攻击法术(5)
	}

	for n = 1, 7 do
		local 模型 = 取随机怪(任务数据[任务id].等级, 任务数据[任务id].等级)
		战斗单位[n + 1] = {
			愤怒 = 9999,
			名称 = 模型[2] .. "喽罗",
			模型 = 模型[2],
			气血 = 阶段属性[等级].气血 * 0.3 * 气血,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.6,
			灵力 = 阶段属性[等级].法伤 * 0.7,
			速度 = 阶段属性[等级].速度 * 0.4,
			防御 = 阶段属性[等级].防御 * 0.05,
			法防 = 阶段属性[等级].法防 * 0.05,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 技能,
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取副本三妖信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 9999,
		模型 = "地狱战神",
		名称 = 任务数据[任务id].名称,
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	等级 = 等级 - 5
	战斗单位[2] = {
		愤怒 = 9999,
		模型 = "地狱战神",
		名称 = "妖怪守卫",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级连击"
		},
		主动技能 = {}
	}
	战斗单位[3] = {
		愤怒 = 9999,
		模型 = "兔子怪",
		名称 = "妖怪守卫",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级连击"
		},
		主动技能 = {}
	}
	战斗单位[4] = {
		愤怒 = 9999,
		模型 = "牛头",
		名称 = "妖怪士兵",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(2)
	}
	战斗单位[5] = {
		愤怒 = 9999,
		模型 = "牛头",
		名称 = "妖怪士兵",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(2)
	}
	战斗单位[6] = {
		愤怒 = 9999,
		模型 = "牛头",
		名称 = "妖怪士兵",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(2)
	}
	战斗单位[7] = {
		愤怒 = 9999,
		模型 = "牛头",
		名称 = "妖怪士兵",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(2)
	}
	战斗单位[8] = {
		愤怒 = 9999,
		模型 = "牛头",
		名称 = "妖怪士兵",
		伤害 = 阶段属性[等级].伤害 * 0.7,
		气血 = 阶段属性[等级].气血 * 0.6,
		灵力 = 阶段属性[等级].法伤 * 0.7,
		速度 = 阶段属性[等级].速度 * 0.3,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(2)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取副本国王信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 9999,
		模型 = "大力金刚",
		名称 = "乌鸡国王",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 1,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 0.8,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		愤怒 = 9999,
		模型 = "蛤蟆精",
		名称 = "侍从",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[3] = {
		愤怒 = 9999,
		模型 = "蛤蟆精",
		名称 = "侍从",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[4] = {
		愤怒 = 9999,
		模型 = "蛤蟆精",
		名称 = "侍从",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[5] = {
		愤怒 = 9999,
		模型 = "蛤蟆精",
		名称 = "侍从",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[6] = {
		愤怒 = 9999,
		模型 = "狐狸精",
		名称 = "侍女",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[7] = {
		愤怒 = 9999,
		模型 = "狐狸精",
		名称 = "侍女",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[8] = {
		愤怒 = 9999,
		模型 = "狐狸精",
		名称 = "侍女",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[9] = {
		愤怒 = 9999,
		模型 = "狐狸精",
		名称 = "侍女",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[10] = {
		愤怒 = 9999,
		模型 = "狐狸精",
		名称 = "侍女",
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 0.5,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 / 2,
		魔法 = 阶段属性[等级].魔法 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取天蓬娶亲1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 50
	local 怪物名称 = {
		{
			"猪头七",
			"骷髅怪",
			{
				"驱鬼",
				"感知",
				"强力"
			},
			{
				"阎罗令",
				"判官令",
				"横扫千军"
			}
		},
		{
			"蛤蟆精喽啰",
			"蛤蟆精",
			{
				"敏捷",
				"高级魔之心",
				"高级法术连击",
				"神佑复生"
			},
			{
				"奔雷咒",
				"泰山压顶",
				"烈火",
				"水攻"
			}
		},
		{
			"羊头怪喽啰",
			"羊头怪",
			{
				"高级敏捷",
				"溜之大吉",
				"神佑复生"
			},
			{
				"百万神兵",
				"失心符",
				"含情脉脉"
			}
		},
		{
			"猪小弟",
			"野猪",
			{
				"必杀",
				"连击",
				"夜战"
			},
			{}
		},
		{
			"猪小弟",
			"野猪",
			{
				"必杀",
				"连击",
				"夜战"
			},
			{}
		}
	}

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 0.8,
			气血 = 阶段属性[等级].气血 * 0.8,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 1
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.4
	战斗单位[1].角色 = true
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.5
	战斗单位[3].速度 = 阶段属性[等级].速度 * 1.5
	战斗单位[3].物伤减少 = 0.5
	战斗单位[3].法伤减少 = 0.5

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取天蓬娶亲2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 50
	local 怪物名称 = {
		{
			"哨探头领",
			"牛头",
			{
				"高级魔之心",
				"驱怪",
				"法术暴击",
				"神佑复生"
			},
			{
				"三昧真火",
				"雨落寒沙",
				"龙卷雨击"
			}
		},
		{
			"蛮牛斥候",
			"牛妖",
			{
				"高级必杀",
				"迟钝",
				"高级连击",
				"高级进击必杀"
			},
			{}
		},
		{
			"潜鲛斥候",
			"鲛人",
			{
				"高级敏捷",
				"溜之大吉",
				"神佑复生"
			},
			{
				"百万神兵",
				"失心符",
				"含情脉脉"
			}
		},
		{
			"哨鹰",
			"雷鸟人",
			{
				"魔之心",
				"法术连击",
				"法术暴击"
			},
			{
				"奔雷咒",
				"雷击"
			}
		},
		{
			"哨鹰",
			"雷鸟人",
			{
				"魔之心",
				"法术连击",
				"法术暴击"
			},
			{
				"奔雷咒",
				"雷击"
			}
		}
	}

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 0.9,
			气血 = 阶段属性[等级].气血 * 0.9,
			灵力 = 阶段属性[等级].法伤 * 0.9,
			速度 = 阶段属性[等级].速度 * 0.55,
			防御 = 阶段属性[等级].防御 * 0.25,
			法防 = 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 1.1
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.1
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.4
	战斗单位[1].角色 = true
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.5
	战斗单位[2].物伤减少 = 1.2
	战斗单位[3].速度 = 阶段属性[等级].速度 * 1.7
	战斗单位[3].物伤减少 = 0.3
	战斗单位[3].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取天蓬娶亲3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 50
	local 怪物名称 = {
		{
			"山门守将",
			"天将",
			{
				"必杀",
				"敏捷",
				"感知",
				"驱鬼"
			},
			{
				"狮搏",
				"连环击",
				"鹰击"
			}
		},
		{
			"大力守卫",
			"马面",
			{
				"高级必杀",
				"高级强力"
			},
			{
				"横扫千军"
			}
		},
		{
			"妖翼守卫",
			"蝴蝶仙子",
			{
				"高级敏捷",
				"溜之大吉",
				"神佑复生"
			},
			{
				"百万神兵",
				"失心符",
				"含情脉脉"
			}
		},
		{
			"暗影猎豹",
			"龙须豹",
			{
				"冲击",
				"高级连击",
				"敏捷"
			},
			{}
		},
		{
			"暗影猎豹",
			"龙须豹",
			{
				"冲击",
				"连击",
				"敏捷"
			},
			{}
		}
	}

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.45,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 1.3
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.2
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.4
	战斗单位[1].角色 = true
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.3
	战斗单位[2].物伤减少 = 1.2
	战斗单位[2].速度 = 等级 * 4
	战斗单位[3].速度 = 阶段属性[等级].速度 * 2
	战斗单位[3].物伤减少 = 0.3
	战斗单位[3].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取天蓬娶亲4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 55
	local 怪物名称 = {
		{
			"天蓬元帅",
			"猪八戒",
			{
				"高级必杀",
				"高级法术暴击",
				"高级敏捷",
				"驱怪"
			},
			{
				"横扫千军",
				"天诛地灭",
				"雨落寒沙"
			}
		},
		{
			"冷血侍卫",
			"僵尸",
			{
				"高级鬼魂术",
				"高级强力",
				"高级必杀",
				"高级敏捷"
			},
			{}
		},
		{
			"无畏勇士",
			"天将",
			{
				"高级必杀",
				"神佑复生"
			},
			{
				"破血狂攻",
				"弱点击破",
				"天雷斩"
			}
		},
		{
			"密宗巫师",
			"幽灵",
			{
				"高级防御",
				"高级再生"
			},
			{
				"推气过宫",
				"起死回生",
				"普渡众生",
				"我佛慈悲"
			}
		},
		{
			"无畏术师",
			"蚌精",
			{
				"高级魔之心",
				"法术连击",
				"敏捷"
			},
			{
				"水漫金山",
				"水攻"
			}
		},
		{
			"神秘萨满",
			"白無常",
			{
				"高级敏捷",
				"溜之大吉"
			},
			{
				"百万神兵",
				"失心符",
				"含情脉脉",
				"日月乾坤"
			}
		}
	}

	for n = 1, 6 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 1.2,
			气血 = 阶段属性[等级].气血 * 1.2,
			灵力 = 阶段属性[等级].法伤 * 1.2,
			速度 = 阶段属性[等级].速度 * 0.8,
			防御 = 阶段属性[等级].防御 * 0.35,
			法防 = 阶段属性[等级].法防 * 0.45,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 2.2
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.8
	战斗单位[1].角色 = true
	战斗单位[1].法伤减少 = 0.8
	战斗单位[1].物伤减少 = 0.8
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.5
	战斗单位[2].物伤减少 = 1.5
	战斗单位[2].速度 = 阶段属性[等级].速度 * 1.7
	战斗单位[3].速度 = 阶段属性[等级].速度 * 1.75
	战斗单位[3].气血 = 等级 * 等级 * 4
	战斗单位[4].物伤减少 = 0.5
	战斗单位[4].法伤减少 = 1.5
	战斗单位[5].灵力 = 阶段属性[等级].法伤 * 1.8
	战斗单位[6].速度 = 阶段属性[等级].速度 * 2.2
	战斗单位[6].气血 = 阶段属性[等级].气血 * 2

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取白龙闹海1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 60
	local 怪物名称 = {
		{
			"万圣公主",
			"小龙女",
			{
				"高级法术连击",
				"高级魔之心",
				"高级感知",
				"高级法术抵抗"
			},
			{
				"龙卷雨击",
				"龙腾",
				"二龙戏珠",
				"龙吟"
			}
		},
		{
			"女神官",
			"蚌精",
			{
				"驱怪",
				"高级魔之心",
				"高级法术连击"
			},
			{
				"水漫金山",
				"水攻"
			}
		},
		{
			"侍卫长",
			"碧水夜叉",
			{
				"高级必杀",
				"溜之大吉",
				"神佑复生"
			},
			{
				"雷霆万钧",
				"天雷斩"
			}
		},
		{
			"公主侍女",
			"泪妖",
			{
				"高级敏捷",
				"高级防御",
				"水属性吸收",
				"神佑复生"
			},
			{
				"失心符",
				"似玉生香"
			}
		},
		{
			"公主侍女",
			"泪妖",
			{
				"高级敏捷",
				"高级防御",
				"水属性吸收"
			},
			{
				"镇妖",
				"离魂符",
				"如花解语"
			}
		}
	}

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 0.9,
			气血 = 阶段属性[等级].气血 * 0.9,
			灵力 = 阶段属性[等级].法伤 * 0.9,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.3
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.4
	战斗单位[1].角色 = true
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.5
	战斗单位[3].速度 = 阶段属性[等级].速度 * 1.8
	战斗单位[3].物伤减少 = 0.5
	战斗单位[3].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取白龙闹海2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 60
	local 怪物名称 = {
		{
			"九头虫",
			"龙太子",
			{
				"高级必杀",
				"高级进击必杀",
				"高级感知",
				"高级法术抵抗"
			},
			{
				"烟雨剑法",
				"龙腾",
				"横扫千军",
				"狮搏"
			}
		},
		{
			"奔波尔霸",
			"碧水夜叉",
			{
				"溜之大吉",
				"高级敏捷",
				"高级防御"
			},
			{
				"镇妖",
				"离魂符",
				"如花解语"
			}
		},
		{
			"霸波尔奔",
			"碧水夜叉",
			{
				"高级必杀",
				"高级连击",
				"烈焰斩",
				"高级进击必杀"
			},
			{}
		},
		{
			"秘魔",
			"野鬼",
			{
				"高级必杀",
				"高级鬼魂术",
				"水属性吸收",
				"高级偷袭"
			},
			{
				"惊心一剑",
				"判官令",
				"狮搏"
			}
		},
		{
			"秘魔",
			"野鬼",
			{
				"高级法术连击",
				"魔之心",
				"水属性吸收"
			},
			{
				"奔雷咒",
				"水漫金山",
				"烈火"
			}
		},
		{
			"秘魔",
			"野鬼",
			{
				"高级法术连击",
				"魔之心",
				"水属性吸收"
			},
			{
				"奔雷咒",
				"水漫金山",
				"烈火"
			}
		}
	}

	for n = 1, 6 do
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1.1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.8,
			防御 = 阶段属性[等级].防御 * 0.25,
			法防 = 阶段属性[等级].法防 * 0.45,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 1.8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.3
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.3
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.4
	战斗单位[1].角色 = true
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].法伤减少 = 0.7
	战斗单位[2].物伤减少 = 0.7
	战斗单位[2].速度 = 阶段属性[等级].速度 * 1.8
	战斗单位[3].物伤减少 = 1.3
	战斗单位[3].法伤减少 = 0.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取白龙闹海3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 60
	local 怪物名称 = {
		{
			"九头虫相柳合体",
			"帮派妖兽",
			{
				"高级必杀",
				"高级进击必杀",
				"高级感知",
				"高级法术抵抗"
			},
			{
				"破血狂攻",
				"弱点击破",
				"横扫千军",
				"鹰击",
				"连环击"
			}
		},
		{
			"万圣公主",
			"小龙女",
			{
				"高级法术连击",
				"高级魔之心",
				"高级感知",
				"高级法术抵抗"
			},
			{
				"龙卷雨击",
				"龙腾",
				"二龙戏珠",
				"龙吟"
			}
		},
		{
			"无面",
			"地狱战神",
			{
				"高级敏捷",
				"溜之大吉",
				"神佑复生"
			},
			{
				"镇妖",
				"离魂符",
				"如花解语"
			}
		},
		{
			"无情",
			"马面",
			{
				"高级必杀",
				"高级进击必杀",
				"高级鬼魂术",
				"高级偷袭"
			},
			{
				"横扫千军",
				"破血狂攻"
			}
		},
		{
			"不死妖凰",
			"凤凰",
			{
				"高级法术连击",
				"高级火属性吸收",
				"神佑复生"
			},
			{
				"地狱烈火",
				"烈火",
				"上古灵符"
			}
		}
	}

	for n = 1, 5 do
		战斗单位[n] = {
			愤怒 = 9999,
			变异 = true,
			名称 = 怪物名称[n][1],
			模型 = 怪物名称[n][2],
			伤害 = 阶段属性[等级].伤害 * 1.1,
			气血 = 阶段属性[等级].气血 * 1.5,
			灵力 = 阶段属性[等级].法伤 * 1.1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.35,
			法防 = 阶段属性[等级].法防 * 0.55,
			躲避 = 阶段属性[等级].躲避 / 2,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[n][3],
			主动技能 = 怪物名称[n][4]
		}
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 2.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.6
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法伤减少 = 0.8
	战斗单位[1].物伤减少 = 0.8
	战斗单位[1].角色 = true
	战斗单位[1].不可封印 = true
	战斗单位[2].角色 = true
	战斗单位[3].速度 = 阶段属性[等级].速度 * 2
	战斗单位[3].物伤减少 = 0.5
	战斗单位[3].法伤减少 = 1.3
	战斗单位[4].法伤减少 = 0.5
	战斗单位[4].物伤减少 = 1.3
	战斗单位[5].物伤减少 = 0.5
	战斗单位[5].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取门派入侵(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz2(玩家数据[玩家id].角色.数据.等级 / 10) * 10
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"夜战",
				"连击",
				"必杀"
			},
			{},
			{}
		},
		{
			"帮手",
			"强盗",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			小法技能,
			{}
		},
		{
			"帮手",
			"山贼",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{}
		}
	}
	local 可选 = {
		2,
		3
	}
	local 队伍人数 = 取队伍人数(玩家id)

	for n = 1, 队伍人数 * 2 do
		local i = n

		if i > 3 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 0.6,
			气血 = 阶段属性[等级].气血 * 0.6,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4]
		}
		战斗单位[1].气血 = 阶段属性[等级].气血 * 0.8

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取突厥精英(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = qz2(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) / 10) * 10
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"突厥法师",
			"花妖",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			"突厥战士",
			"山贼",
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生"
			},
			{},
			{}
		},
		{
			"突厥战士",
			"强盗",
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"突厥阴魂",
			"野鬼",
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			"突厥巫师",
			"进阶蝴蝶仙子",
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			"突厥巫医",
			"进阶凤凰",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 取随机数(8, 10) do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 3,
				魔法 = 阶段属性[等级].魔法 * 20,
				伤害 = 阶段属性[等级].伤害 * 1.5,
				灵力 = 阶段属性[等级].法伤 * 1.6,
				速度 = 阶段属性[等级].速度 * 1.7,
				防御 = 阶段属性[等级].防御 * 0.4,
				法防 = 阶段属性[等级].法防 * 0.4,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.05,
				灵力 = 阶段属性[等级].法伤 * 1.15,
				速度 = 阶段属性[等级].速度 * 0.9,
				防御 = 阶段属性[等级].防御 * 0.2,
				法防 = 阶段属性[等级].法防 * 0.2,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	local aa = ygsj(3)

	if aa == 1 then
		战斗单位[1].物伤减少 = 0.5
		战斗单位[1].法伤减少 = 1.5
	elseif aa == 2 then
		战斗单位[1].物伤减少 = 1.5
		战斗单位[1].法伤减少 = 0.5
	else
		战斗单位[1].物伤减少 = 0.9
		战斗单位[1].法伤减少 = 0.9
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取突厥探子(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = qz2(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) / 10 - 1) * 10
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"感知",
				"夜战",
				"神佑复生",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"突厥喽啰",
			"强盗",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"突厥喽啰",
			"山贼",
			{},
			{},
			{}
		},
		{
			"突厥喽啰",
			"强盗",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"突厥巫医",
			"进阶凤凰",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"突厥巫师",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}
	local 队伍人数 = 取队伍人数(玩家id)

	for n = 1, 取随机数(6, 队伍人数 * 2) do
		local i = n
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.1,
				灵力 = 阶段属性[等级].法伤 * 1.2,
				速度 = 阶段属性[等级].速度 * 1.4,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.3,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.2,
				法防 = 阶段属性[等级].法防 * 0.2,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	local aa = ygsj(3)

	if aa == 1 then
		战斗单位[1].物伤减少 = 0.5
		战斗单位[1].法伤减少 = 1.3
	elseif aa == 2 then
		战斗单位[1].物伤减少 = 1.3
		战斗单位[1].法伤减少 = 0.5
	else
		战斗单位[1].物伤减少 = 0.9
		战斗单位[1].法伤减少 = 0.9
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = "天覆阵"
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"小白龙",
			"蛟龙",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			{},
			{}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"小龙女巫医",
			"小龙女",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"小龙女巫师",
			"小龙女",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 3,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.5
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = "天覆阵"
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"梦之魅",
			"僵尸",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.阴曹地府,
			{}
		},
		{
			"野鬼喽啰",
			"野鬼",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"野鬼喽啰",
			"野鬼",
			{},
			{},
			{}
		},
		{
			"野鬼喽啰",
			"野鬼",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"野鬼巫医",
			"野鬼",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"野鬼巫师",
			"野鬼",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"土属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 4
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.5
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = "蛇蟠阵"
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"血之魅",
			"僵尸",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.阴曹地府,
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			{},
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"骷髅怪巫医",
			"骷髅怪",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"骷髅怪巫师",
			"骷髅怪",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"火属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 4
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = "虎翼阵"
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"森之魅",
			"僵尸",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.阴曹地府,
			{}
		},
		{
			"雷鸟人喽啰",
			"雷鸟人",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"雷鸟人喽啰",
			"雷鸟人",
			{},
			{},
			{}
		},
		{
			"雷鸟人喽啰",
			"雷鸟人",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"雷鸟人巫医",
			"雷鸟人",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"雷鸟人巫师",
			"雷鸟人",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙5(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"奔波儿灞",
			"蛤蟆精",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			{},
			{}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"虾兵巫医",
			"虾兵",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"虾兵巫师",
			"虾兵",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙6(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"蟹将军",
			"蟹将",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			{},
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"虾兵巫医",
			"虾兵",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"蟹将巫师",
			"蟹将",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙7(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 75
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"虾将军",
			"虾兵",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			{},
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"蟹将巫师",
			"蟹将",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"虾兵巫医",
			"虾兵",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙8(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 80
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"天庭侍卫",
			"天将",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.天宫,
			{}
		},
		{
			"天兵喽啰",
			"天兵",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"天兵喽啰",
			"天兵",
			{},
			{},
			{}
		},
		{
			"天兵喽啰",
			"天兵",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"天兵巫师",
			"天兵",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"天兵巫医",
			"天兵",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 9 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙9(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 80
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"万圣公主",
			"蛟龙",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{
				法伤减少 = 0.7,
				物伤减少 = 0.7
			}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			{},
			{}
		},
		{
			"小龙女喽啰",
			"小龙女",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"小龙女巫师",
			"小龙女",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"小龙女巫医",
			"小龙女",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 10 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取含冤小白龙11(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 80
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"牛妖亲兵",
			"牛妖",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.魔王寨,
			{}
		},
		{
			"牛妖喽啰",
			"牛妖",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"牛妖喽啰",
			"牛妖",
			{},
			{},
			{}
		},
		{
			"牛妖喽啰",
			"牛妖",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"牛妖巫师",
			"牛妖",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"牛妖巫医",
			"牛妖",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取含冤小白龙12(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 85
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"九头精怪",
			"九头精怪",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{
				法伤减少 = 1.5,
				物伤减少 = 0.5
			}
		},
		{
			"虾兵喽啰",
			"虾兵",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			{},
			{}
		},
		{
			"蟹将喽啰",
			"蟹将",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"虾兵巫师",
			"虾兵",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"蟹将巫医",
			"蟹将",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 10 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].不可封印 = true
	战斗单位[1].气血 = 阶段属性[等级].气血 * 10
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取含冤小白龙13(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 90
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"天庭侍卫",
			"天兵",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.天宫,
			{}
		},
		{
			"雨师喽啰",
			"雨师",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"风伯喽啰",
			"风伯",
			{},
			{},
			{}
		},
		{
			"风伯喽啰",
			"风伯",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"雨师巫师",
			"雨师",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"风伯巫医",
			"风伯",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取女娲神迹1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			"春十三娘",
			"蜘蛛精",
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			Q_门派法术.盘丝洞,
			{}
		},
		{
			"蜘蛛精喽啰",
			"蜘蛛精",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生"
			},
			{},
			{}
		},
		{
			"狐狸精喽啰",
			"狐狸精",
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"盘丝阴魂",
			"野鬼",
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			"盘丝巫师",
			"进阶蝴蝶仙子",
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			"盘丝巫医",
			"花妖",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].不可封印 = true
	战斗单位[1].气血 = 阶段属性[等级].气血 * 10
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].物伤减少 = 0.5
	战斗单位[1].法伤减少 = 0.5
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取八戒悟空1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"康太尉",
			"天兵",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.天宫,
			{}
		},
		{
			"巡游天神喽啰",
			"巡游天神",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"天将喽啰",
			"天将",
			{},
			{},
			{}
		},
		{
			"天将喽啰",
			"天将",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"巡游天神巫师",
			"巡游天神",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"天将巫医",
			"天将",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 6 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"家丁",
			"山贼",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.大唐官府,
			{}
		},
		{
			"山贼喽啰",
			"山贼",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"护卫喽啰",
			"护卫",
			{},
			{},
			{}
		},
		{
			"护卫喽啰",
			"护卫",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"山贼巫师",
			"山贼",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"护卫巫医",
			"护卫",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"冤魂",
			"僵尸",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.大唐官府,
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"野鬼喽啰",
			"野鬼",
			{},
			{},
			{}
		},
		{
			"野鬼喽啰",
			"野鬼",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"骷髅怪巫师",
			"骷髅怪",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"野鬼巫医",
			"野鬼",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 105
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"哮天犬",
			"哮天犬",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.天宫,
			{}
		},
		{
			"天兵喽啰",
			"天兵",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"天将喽啰",
			"天将",
			{},
			{},
			{}
		},
		{
			"天将喽啰",
			"天将",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"天兵巫师",
			"天兵",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"天将巫医",
			"天将",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空5(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 110
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"龙神",
			"蛟龙",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"古代瑞兽喽啰",
			"古代瑞兽",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"地狱战神喽啰",
			"地狱战神",
			{},
			{},
			{}
		},
		{
			"地狱战神喽啰",
			"地狱战神",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"古代瑞兽巫师",
			"古代瑞兽",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"地狱战神巫医",
			"地狱战神",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空6(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 110
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"吊死鬼",
			"野鬼",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.阴曹地府,
			{}
		},
		{
			"僵尸喽啰",
			"僵尸",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			{},
			{}
		},
		{
			"骷髅怪喽啰",
			"骷髅怪",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"僵尸巫师",
			"僵尸",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"骷髅怪巫医",
			"骷髅怪",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"火属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 8
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取八戒悟空7(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 115
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			"青灵玄女",
			"如意仙子",
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.五庄观,
			{}
		},
		{
			"星灵仙子喽啰",
			"星灵仙子",
			{},
			夜光随机法术(3),
			{}
		},
		{
			"蛟龙喽啰",
			"蛟龙",
			{},
			{},
			{}
		},
		{
			"蛟龙喽啰",
			"蛟龙",
			{},
			夜光随机物理法术(3),
			{}
		},
		{
			"星灵仙子巫师",
			"星灵仙子",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"蛟龙巫医",
			"蛟龙",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 8 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"水属性吸收",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 10
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.6
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.6
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取大闹抢水信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 数量 = 1
	local 怪物名称 = {
		{
			"抢水蟊贼",
			"黑熊精",
			{
				"高级夜战",
				"高级感知",
				"高级必杀",
				"高级连击"
			},
			{},
			{}
		}
	}

	for n = 1, 数量 do
		local i = n
		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 0.8,
			气血 = 阶段属性[等级].气血 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 0.8,
			速度 = 阶段属性[等级].速度 * 0.8,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.15,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取大闹除虫信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 数量 = 1
	local 怪物名称 = {
		{
			"虫豸精怪",
			"海毛虫",
			{
				"高级夜战",
				"高级感知",
				"高级必杀",
				"高级连击"
			},
			{},
			{}
		}
	}

	for n = 1, 数量 do
		local i = n
		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.15,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取大闹仙女信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			"七仙女",
			"芙蓉仙子",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"贞烈仙女",
			"芙蓉仙子",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.5
			}
		},
		{
			"贞烈仙女",
			"芙蓉仙子",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"贞烈仙女",
			"芙蓉仙子",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{}
		},
		{
			"贞烈仙女",
			"芙蓉仙子",
			{
				"必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"贞烈仙女",
			"芙蓉仙子",
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"温婉仙女",
			"如意仙子",
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 6 + ygsj(2) do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.75,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.7,
				灵力 = 阶段属性[等级].法伤 * 0.8,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取大闹造酒信息(任务id, 玩家id)
	return self:大闹天宫4(任务id, 玩家id)
end

function 战斗准备类:取大闹运水信息(任务id, 玩家id)
	return self:大闹天宫4(任务id, 玩家id)
end

function 战斗准备类:取大闹盘槽信息(任务id, 玩家id)
	return self:大闹天宫4(任务id, 玩家id)
end

function 战斗准备类:取大闹烧火信息(任务id, 玩家id)
	return self:大闹天宫4(任务id, 玩家id)
end

function 战斗准备类:取大闹天兵信息(任务id, 玩家id)
	return self:大闹天宫5(任务id, 玩家id, "天兵")
end

function 战斗准备类:取大闹天将信息(任务id, 玩家id)
	return self:大闹天宫5(任务id, 玩家id, "天将")
end

function 战斗准备类:取大闹二郎神信息(任务id, 玩家id)
	return self:大闹天宫6(任务id, 玩家id, "二郎神", "二郎真君")
end

function 战斗准备类:取大闹惠岸行者信息(任务id, 玩家id)
	return self:大闹天宫6(任务id, 玩家id, "净瓶女娲", "惠岸行者")
end

function 战斗准备类:取大闹上古雷神信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			"上古雷神",
			"进阶雷龙",
			{
				"高级感知",
				"高级夜战",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			{
				"龙卷雨击",
				"雷霆万钧"
			},
			{}
		},
		{
			"天兵",
			"天兵",
			{
				"高级连击",
				"高级必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"天兵",
			"天兵",
			{
				"高级连击",
				"高级必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"天将",
			"天将",
			{
				"高级法术暴击",
				"高级法术连击",
				"高级法术波动"
			},
			夜光随机法术(3),
			{
				灵力 = 1.3,
				法防 = 2
			}
		},
		{
			"天将",
			"天将",
			{
				"高级法术暴击",
				"高级法术连击",
				"高级法术波动"
			},
			夜光随机法术(3),
			{
				灵力 = 1.3,
				法防 = 2
			}
		},
		{
			"治愈仙",
			"净瓶女娲",
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"扰敌仙",
			"灵符女娲",
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		},
		{
			"利刃仙",
			"进阶巡游天神",
			{
				"高级必杀",
				"夜战"
			},
			Q_门派法术.大唐官府,
			{
				法伤减少 = 0.5
			}
		}
	}
	local 可选 = {
		2,
		4
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 8 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 2,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.5,
				灵力 = 阶段属性[等级].法伤 * 1.6,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.5,
				法防 = 阶段属性[等级].法防 * 0.6,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.2,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.4,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大闹天宫6(任务id, 玩家id, 模型, 主怪名称)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			主怪名称,
			模型,
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"治愈仙",
			"净瓶女娲",
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"扰敌仙",
			"灵符女娲",
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		},
		{
			"妙法仙",
			"雾中仙",
			{
				"法术暴击",
				"法术连击",
				"法术波动"
			},
			{
				"雷霆万钧"
			},
			{
				灵力 = 1.3,
				法防 = 2
			}
		},
		{
			"妙法仙",
			"雾中仙",
			{
				"法术暴击",
				"法术连击",
				"法术波动"
			},
			{
				"雷霆万钧"
			},
			{
				灵力 = 1.3,
				法防 = 2
			}
		},
		{
			"利刃仙",
			"修罗傀儡鬼",
			{
				"连击",
				"必杀",
				"夜战"
			},
			Q_门派法术.狮驼岭,
			{
				防御 = 2
			}
		},
		{
			"天兵",
			"天兵",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"天兵",
			"天兵",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		}
	}
	local 可选 = {
		7,
		8
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 10 do
		local i = n

		if i > 8 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.2,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.35,
				法防 = 阶段属性[等级].法防 * 0.35,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.15,
				法防 = 阶段属性[等级].法防 * 0.15,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大闹天宫5(任务id, 玩家id, 模型)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			模型 .. "统领",
			模型,
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{}
		},
		{
			"遮" .. 模型,
			模型,
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"遮" .. 模型,
			模型,
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"接力仙",
			"金身罗汉",
			{
				"必杀",
				"夜战",
				"防御",
				"强力"
			},
			{
				"后发制人"
			},
			{
				速度 = 2,
				伤害 = 1.5
			}
		},
		{
			"急先锋",
			"大力金刚",
			{
				"必杀",
				"夜战"
			},
			{
				"狮搏",
				"鹰击",
				"连环击"
			},
			{}
		},
		{
			"遮" .. 模型,
			模型,
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"遮" .. 模型,
			模型,
			{
				"法术连击",
				"敏捷",
				"法术暴击",
				"法术波动"
			},
			夜光随机恢复法术(3),
			{
				速度 = 2.5,
				气血 = 1.5
			}
		},
		{
			"遮" .. 模型,
			模型,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 8 do
		local i = n

		if i > 8 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		if n == 1 then
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = true,
				饰品 = true,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.2,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 0.3,
				法防 = 阶段属性[等级].法防 * 0.3,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4],
				攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
				抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
			}
		else
			战斗单位[n] = {
				愤怒 = 9999,
				变异 = false,
				名称 = 怪物名称[i][1],
				模型 = 怪物名称[i][2],
				气血 = 阶段属性[等级].气血 * 0.7,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 0.8,
				灵力 = 阶段属性[等级].法伤 * 0.9,
				速度 = 阶段属性[等级].速度 * 0.7,
				防御 = 阶段属性[等级].防御 * 0.1,
				法防 = 阶段属性[等级].法防 * 0.1,
				躲避 = 阶段属性[等级].躲避 * 0.5,
				等级 = 等级,
				技能 = 怪物名称[i][3],
				主动技能 = 怪物名称[i][4]
			}
		end

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大闹天宫4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 怪物名称 = {
		{
			"造酒信息",
			"护卫",
			{
				"感知",
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[门派名称[ygsj(#门派名称)]],
			{
				气血 = 1.5
			}
		},
		{
			"运水道人",
			"雨师",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"烧火童子",
			"小魔头",
			{
				"连击",
				"必杀",
				"夜战"
			},
			{},
			{
				伤害 = 1.3
			}
		},
		{
			"盘槽力士",
			"风伯",
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动"
			},
			{
				"水攻",
				"落岩",
				"雷击",
				"烈火"
			},
			{
				灵力 = 1.5,
				法伤减少 = 0.5
			}
		}
	}
	local 可选 = {
		3,
		4,
		5,
		6
	}
	位置 = {
		[4] = 夜光随机法术,
		[5] = 夜光随机物理法术,
		[6] = 夜光随机恢复法术
	}

	for n = 1, 4 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = true,
			饰品 = true,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			气血 = 阶段属性[等级].气血 * 1.5,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 1.2,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取黑风山除虫(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 玩家数据[id].角色.数据.等级
	}
	阵容.怪物数据[1] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.7,
		防御 = 0.1,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山打扫(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 玩家数据[id].角色.数据.等级
	}
	阵容.怪物数据[1] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.7,
		模型 = "大蝙蝠",
		名称 = "脏东西",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山鬼魂(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 玩家数据[id].角色.数据.等级
	}
	阵容.怪物数据[1] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.3,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.5,
		防御 = 0.3,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[2] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.3,
		变异 = false,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.5,
		防御 = 0.3,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山恶虎(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 1.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.7,
		防御 = 0.2,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"高级必杀",
			"感知"
		},
		主动技能 = {
			鹰击
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.6,
		模型 = "噬天虎",
		名称 = "母老虎",
		防御 = 0.2,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = 狮搏
	}
	阵容.怪物数据[3] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.5,
		模型 = "老虎",
		名称 = "小虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.8,
		模型 = "老虎",
		名称 = "大虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"健壮",
			"敏捷",
			"盾气",
			"幸运",
			"防御",
			"反震",
			"水属性吸收"
		},
		主动技能 = {
			"普渡众生"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 0.8,
		模型 = "老虎",
		名称 = "二虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"健壮",
			"敏捷",
			"盾气",
			"幸运",
			"防御",
			"反震",
			"雷属性吸收"
		},
		主动技能 = {
			"生命之泉"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.3,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 1,
		模型 = "狐狸精",
		名称 = "假虎狐",
		防御 = 0.3,
		修炼 = {},
		被动技能 = {
			"健壮",
			"敏捷",
			"盾气",
			"幸运",
			"防御",
			"反震",
			"土属性吸收"
		},
		主动技能 = {
			"金刚护体"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "老虎",
		名称 = "小虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "老虎",
		名称 = "小虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[9] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "老虎",
		名称 = "小虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[10] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.5,
		模型 = "老虎",
		名称 = "小虎",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山鬼鬼祟祟黑熊精(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 2,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.8,
		防御 = 0.1,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.5,
		愤怒 = 9999,
		气血 = 0.5,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.3,
		法伤 = 0.5,
		速度 = 0.6,
		模型 = "鼠先锋",
		名称 = "窃宝鼠",
		防御 = 0.3,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.5,
		愤怒 = 9999,
		气血 = 0.5,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.3,
		法伤 = 0.5,
		速度 = 0.6,
		模型 = "鼠先锋",
		名称 = "窃宝鼠",
		防御 = 0.3,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.5,
		愤怒 = 9999,
		气血 = 0.5,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.3,
		法伤 = 0.5,
		速度 = 0.6,
		模型 = "鼠先锋",
		名称 = "窃宝鼠",
		防御 = 0.3,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.5,
		愤怒 = 9999,
		气血 = 0.5,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.3,
		法伤 = 0.5,
		速度 = 0.6,
		模型 = "鼠先锋",
		名称 = "窃宝鼠",
		防御 = 0.3,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.5,
		愤怒 = 9999,
		气血 = 0.8,
		法防 = 0.15,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.5,
		速度 = 1,
		模型 = "羊头怪",
		名称 = "护宝羊",
		防御 = 0.15,
		修炼 = {},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[7] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.6,
		模型 = "野猪",
		名称 = "运宝猪",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"烈火",
			"水攻",
			"落岩",
			"雷击"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.6,
		模型 = "野猪",
		名称 = "运宝猪",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"烈火",
			"水攻",
			"落岩",
			"雷击"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.6,
		模型 = "野猪",
		名称 = "运宝猪",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"烈火",
			"水攻",
			"落岩",
			"雷击"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.7,
		速度 = 0.6,
		模型 = "野猪",
		名称 = "运宝猪",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"烈火",
			"水攻",
			"落岩",
			"雷击"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山熊熊烈火(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.9,
		法防 = 0.4,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1.2,
		速度 = 0.8,
		防御 = 0.2,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "凤凰",
		名称 = "火苗",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "凤凰",
		名称 = "火苗",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "凤凰",
		名称 = "火苗",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "凤凰",
		名称 = "火苗",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.5,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "凤凰",
		名称 = "火苗",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"地狱烈火"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 0.5,
		模型 = "树怪",
		名称 = "火柴",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.2,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.8,
		速度 = 1,
		模型 = "风伯",
		名称 = "助火风",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山黑汉(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 1.2,
		愤怒 = 9999,
		气血 = 1.5,
		饰品 = true,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.4,
		法伤 = 1.2,
		速度 = 1,
		模型 = "黑熊精",
		名称 = "黑汉",
		防御 = 0.4,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		伤害 = 1,
		气血 = 1.5,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1,
		防御 = 0.3,
		法防 = 0.3,
		躲避 = 0.5,
		法伤 = 1.4,
		模型 = "雨师",
		名称 = "道人",
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		其他属性 = {
			法伤减少 = 0.8
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		伤害 = 1.1,
		气血 = 1.5,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1,
		防御 = 0.3,
		法防 = 0.3,
		躲避 = 0.5,
		法伤 = 1,
		模型 = "净瓶女娲",
		名称 = "白衣秀士",
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		其他属性 = {
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = 剑荡四方
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山小妖(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 0.8,
		愤怒 = 9999,
		气血 = 0.8,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 0.8,
		速度 = 0.8,
		防御 = 0.2,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[2] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 0.6,
		模型 = "黑熊",
		名称 = "小妖喽啰",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[3] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 0.6,
		模型 = "黑熊",
		名称 = "小妖喽啰",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[4] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 0.6,
		模型 = "老虎",
		名称 = "小妖喽啰",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[5] = {
		伤害 = 1.1,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 1,
		模型 = "黑熊",
		名称 = "巡山妖将",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {
			"后发制人"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 1.2,
		模型 = "狐狸精",
		名称 = "姿色小妖",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"招架",
			"法术抵抗",
			"敏捷",
			"神佑复生",
			"幸运",
			"防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[7] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 0.6,
		模型 = "羊头怪",
		名称 = "小妖喽啰",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.6,
		愤怒 = 9999,
		气血 = 0.6,
		法防 = 0.1,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 0.6,
		速度 = 0.6,
		模型 = "羊头怪",
		名称 = "小妖喽啰",
		防御 = 0.1,
		修炼 = {},
		被动技能 = {
			"夜战",
			"必杀",
			"连击",
			"法术连击",
			"法术暴击"
		},
		主动技能 = {}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取黑风山黑熊精(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		伤害 = 1.2,
		气血 = 2,
		变异 = true,
		魔法 = 10,
		饰品 = true,
		速度 = 1.3,
		防御 = 0.4,
		法防 = 0.4,
		躲避 = 0.5,
		法伤 = 1,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.8,
			物伤减少 = 0.8
		},
		被动技能 = {
			"高级夜战",
			"高级必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[2] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 1,
		模型 = "百足将军",
		名称 = "盈盈",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[3] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 1,
		模型 = "百足将军",
		名称 = "光光",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"鹰击"
		}
	}
	阵容.怪物数据[4] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 1,
		模型 = "野猪精",
		名称 = "欢欢",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"横扫千军"
		}
	}
	阵容.怪物数据[5] = {
		伤害 = 1,
		愤怒 = 9999,
		气血 = 1,
		法防 = 0.2,
		魔法 = 10,
		躲避 = 0.5,
		法伤 = 1,
		速度 = 1,
		模型 = "野猪精",
		名称 = "凌凌",
		防御 = 0.2,
		修炼 = {
			0.5,
			0.5,
			0.5,
			0.5
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"横扫千军"
		}
	}
	阵容.怪物数据[6] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.5,
		模型 = "鼠先锋",
		名称 = "妮妮",
		防御 = 0.2,
		修炼 = {},
		其他属性 = {
			物伤减少 = 0.9
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"天雷斩"
		}
	}
	阵容.怪物数据[7] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.5,
		模型 = "鼠先锋",
		名称 = "甜甜",
		防御 = 0.2,
		修炼 = {},
		其他属性 = {
			物伤减少 = 0.9
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"天雷斩"
		}
	}
	阵容.怪物数据[8] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.5,
		模型 = "鼠先锋",
		名称 = "再再",
		防御 = 0.2,
		修炼 = {},
		其他属性 = {
			物伤减少 = 0.9
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"天雷斩"
		}
	}
	阵容.怪物数据[9] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.5,
		模型 = "鼠先锋",
		名称 = "明明",
		防御 = 0.2,
		修炼 = {},
		其他属性 = {
			物伤减少 = 0.9
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"天雷斩"
		}
	}
	阵容.怪物数据[10] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 0.7,
		魔法 = 10,
		躲避 = 0.5,
		法防 = 0.2,
		法伤 = 1,
		速度 = 0.5,
		模型 = "鼠先锋",
		名称 = "莱莱",
		防御 = 0.2,
		修炼 = {},
		其他属性 = {
			物伤减少 = 0.9
		},
		被动技能 = {
			"夜战",
			"必杀"
		},
		主动技能 = {
			"天雷斩"
		}
	}

	return 战斗数据标准模板(阵容, id, 任务id)
end

取十二祖巫属性 = function(关卡)
	local 主 = {}
	local 小 = {}

	if 关卡 == 1 then
		主.气血 = 3
		主.防御 = 0.6
		主.法防 = 0.7
		主.伤害 = 1.15
		小.气血 = 1
		小.防御 = 0.45
		小.法防 = 0.45
		小.伤害 = 0.85
	elseif 关卡 == 2 then
		主.气血 = 4.5
		主.防御 = 0.85
		主.法防 = 0.95
		主.伤害 = 1.3
		小.气血 = 1.5
		小.防御 = 0.6
		小.法防 = 0.6
		小.伤害 = 1
	elseif 关卡 == 3 then
		主.气血 = 6.5
		主.防御 = 1
		主.法防 = 1.1
		主.伤害 = 1.45
		小.气血 = 2.5
		小.防御 = 0.8
		小.法防 = 0.8
		小.伤害 = 1.15
	end

	return 主, 小
end

function 战斗准备类:取十二祖巫奢比尸(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "虎翼阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.奢比尸 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶炎魔神",
		名称 = "奢比尸",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"超级毒",
			"高级助攻",
			"超级连击",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"剑气四射·觉醒"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.7,
		躲避 = 1,
		模型 = "进阶鬼将",
		名称 = "神勇巫将·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 1.65
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.63,
		躲避 = 1,
		模型 = "火熔石",
		名称 = "赤焰火巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫翕兹(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "天覆阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.翕兹 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶鲛人",
		名称 = "翕兹",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"风起龙游",
			"高级法术暴击",
			"超级进击法爆",
			"法术助攻",
			"高级雷属性吸收",
			"感知",
			"高级法术连击",
			"高级法术穿透"
		},
		主动技能 = {
			"超级奔雷咒",
			"雷击"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.65,
		躲避 = 1,
		模型 = "炎魔神",
		名称 = "巫族先锋·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.6,
		躲避 = 1,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"魔之心"
		},
		主动技能 = {
			"三昧真火"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心",
			"感知"
		},
		主动技能 = {
			"飞砂走石"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫天吴(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "风扬阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.天吴 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶噬天虎",
		名称 = "天吴",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"超级毒",
			"高级助攻",
			"超级连击",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"飘渺式",
			"烟雨剑法",
			"后发制人"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.6,
		躲避 = 1,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.35,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.65,
		躲避 = 1,
		模型 = "炎魔神",
		名称 = "巫族先锋·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"高级法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫强良(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "虎翼阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.强良 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		不可封印 = true,
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 1,
		躲避 = 1.5,
		模型 = "进阶踏云兽",
		名称 = "强良",
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"超级毒",
			"高级助攻",
			"超级连击",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.6,
		躲避 = 1,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.7,
		躲避 = 1,
		模型 = "进阶鬼将",
		名称 = "神勇巫将·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 1.65
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫烛九阴(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "龙飞阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.烛九阴 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶蛟龙",
		名称 = "烛九阴",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"风起龙游",
			"高级法术暴击",
			"超级进击法爆",
			"法术助攻",
			"高级雷属性吸收",
			"感知",
			"高级法术连击",
			"高级法术穿透"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.7,
		躲避 = 1,
		模型 = "进阶鬼将",
		名称 = "神勇巫将·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.63,
		躲避 = 1,
		模型 = "火熔石",
		名称 = "赤焰火巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫后土(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "地载阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.后土 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶雾中仙",
		名称 = "后土",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级健壮",
			"高级敏捷",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"推气过宫",
			"唧唧歪歪",
			"活血",
			"推拿",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"烈焰斩"
		},
		主动技能 = {}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫帝江(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "蛇蟠阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.帝江 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "凤凰",
		名称 = "帝江",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级健壮",
			"高级敏捷",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"日月乾坤",
			"似玉生香",
			"反间计",
			"催眠符"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶噬天虎",
		名称 = "冥渊虎妖",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"高级感知"
		},
		主动技能 = {
			"蚩尤之搏"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶幽灵",
		名称 = "幽雷灵",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"高级法术穿透",
			"高级感知"
		},
		主动技能 = {
			"雷击"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫蓐收(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "蛇蟠阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.蓐收 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶百足将军",
		名称 = "蓐收",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"超级毒",
			"高级助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"剑气四射·觉醒"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶噬天虎",
		名称 = "冥渊虎妖",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"高级感知"
		},
		主动技能 = {
			"蚩尤之搏"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫句芒(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "风扬阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.句芒 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶大力金刚",
		名称 = "句芒",
		不可封印 = true,
		气血 = 主.气血,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"风起龙游",
			"高级法术暴击",
			"超级进击法爆",
			"法术助攻",
			"高级火属性吸收",
			"感知",
			"高级法术连击",
			"高级法术穿透"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶猫灵兽形",
		名称 = "龙须猫巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"金刚护法",
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.65,
		躲避 = 1,
		模型 = "炎魔神",
		名称 = "巫族先锋·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		其他属性 = {
			法伤减少 = 1.65
		},
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫玄冥(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "龙飞阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.玄冥 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶金铙僧",
		名称 = "玄冥",
		不可封印 = true,
		气血 = 主.气血 * 1.2,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级健壮",
			"高级敏捷",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"推气过宫",
			"普度众生",
			"四海升平",
			"推拿"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶噬天虎",
		名称 = "冥渊虎妖",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"高级感知"
		},
		主动技能 = {
			"蚩尤之搏"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.65,
		躲避 = 1,
		模型 = "炎魔神",
		名称 = "巫族先锋·惧法",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		其他属性 = {
			法伤减少 = 1.65
		},
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"感知"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		速度 = 0.6,
		躲避 = 1,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫·惧物",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			物伤减少 = 1.65
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"高级魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙卷雨击"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫共工(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "地载阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.共工 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶碧水夜叉",
		名称 = "共工",
		不可封印 = true,
		气血 = 主.气血 * 1.2,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级健壮",
			"高级敏捷",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震",
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"超级水漫金山",
			"水攻"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶噬天虎",
		名称 = "冥渊虎妖",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"高级感知"
		},
		主动技能 = {
			"蚩尤之搏"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取十二祖巫祝融(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		阵法 = "天覆阵",
		等级 = qz2(取队伍平均等级(玩家数据[id].队伍) / 10) * 10
	}
	local 关卡 = 今日祖巫数据.今日1.祝融 + 0
	local 主, 小 = 取十二祖巫属性(关卡)
	阵容.怪物数据[1] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1.5,
		速度 = 1,
		模型 = "进阶灵灯侍者",
		名称 = "祝融",
		不可封印 = true,
		气血 = 主.气血 * 1.2,
		伤害 = 主.伤害,
		法伤 = 主.伤害 * 1.3,
		防御 = 主.防御,
		法防 = 主.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级健壮",
			"高级敏捷",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震",
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"三昧真火",
			"八凶法阵",
			"上古灵符"
		}
	}
	阵容.怪物数据[2] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶噬天虎",
		名称 = "冥渊虎妖",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复",
			"高级感知"
		},
		主动技能 = {
			"蚩尤之搏"
		}
	}
	阵容.怪物数据[3] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.6,
		模型 = "进阶灵鹤",
		名称 = "凌云鹤巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"魔之心",
			"法术穿透",
			"感知"
		},
		主动技能 = {
			"龙腾"
		}
	}
	阵容.怪物数据[4] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.65,
		模型 = "炎魔神",
		名称 = "巫族先锋",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "变身",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"物理穿透",
			"报复"
		},
		主动技能 = {
			"鹰击",
			"连环击",
			"狮搏"
		}
	}
	阵容.怪物数据[5] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "进阶鬼将",
		名称 = "神勇巫将",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"助攻",
			"感知",
			"高级物理穿透"
		},
		主动技能 = {
			"横扫千军",
			"后发制人"
		},
		指定攻击目标 = {
			"气血",
			"最小"
		}
	}
	阵容.怪物数据[6] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.1,
		模型 = "进阶锦毛貂精",
		名称 = "灵芝貂巫",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"推气过宫",
			"我佛慈悲"
		}
	}
	阵容.怪物数据[7] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 1.1,
		模型 = "进阶混沌兽",
		名称 = "混沌巫医",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害 * 1.5,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		其他属性 = {
			法伤减少 = 0.7,
			物伤减少 = 0.7
		},
		被动技能 = {
			"高级健壮",
			"高级盾气",
			"高级幸运",
			"高级防御",
			"高级反震"
		},
		主动技能 = {
			"灵动九天",
			"普渡众生",
			"杨柳甘露"
		}
	}
	阵容.怪物数据[8] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 2,
		速度 = 1.3,
		模型 = "进阶曼珠沙华",
		名称 = "阳春花妖",
		气血 = 小.气血 * 1.3,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级招架",
			"高级法术抵抗",
			"高级敏捷",
			"神佑复生",
			"高级幸运",
			"高级防御"
		},
		主动技能 = 夜光随机封印法术(3)
	}
	阵容.怪物数据[9] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.7,
		模型 = "夜罗刹",
		名称 = "剑无名",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		被动技能 = {
			"高级夜战",
			"高级必杀",
			"高级进击必杀",
			"助攻",
			"高级连击",
			"物理穿透",
			"影袭",
			"嗜血追击"
		},
		主动技能 = {}
	}
	阵容.怪物数据[10] = {
		愤怒 = 9999,
		角色 = true,
		魔法 = 10,
		躲避 = 1,
		速度 = 0.63,
		模型 = "火熔石",
		名称 = "赤焰火巫",
		气血 = 小.气血,
		伤害 = 小.伤害,
		法伤 = 小.伤害,
		防御 = 小.防御,
		法防 = 小.法防,
		修炼 = {
			1,
			1,
			1,
			1
		},
		附加状态 = {
			{
				名称 = "定心术",
				数量 = 5,
				等级 = 阵容.等级
			}
		},
		被动技能 = {
			"高级法术连击",
			"高级法术暴击",
			"法术助攻",
			"法术穿透",
			"高级魔之心"
		},
		主动技能 = {
			"三昧真火",
			"飞砂走石"
		}
	}

	for i = 1, #阵容.怪物数据 do
		阵容.怪物数据[i].显示饰品 = true
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:保卫长安_先锋(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) - 5
	local 数量 = 取随机数(7, 8)
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 小怪名称 = {
		"术精岐黄",
		"铜墙铁壁",
		"力大无穷",
		"飞檐走壁",
		"外强中干",
		"救死扶伤",
		"固若金汤",
		"身强体壮",
		"铜墙铁壁",
		"杏林高手",
		"生龙活虎",
		"拔山扛鼎"
	}
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[取随机输出门派()],
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = 小怪名称[ygsj(#小怪名称)]
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 2
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_头目(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 取随机数(8, 9)
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 小怪名称 = {
		"术精岐黄",
		"铜墙铁壁",
		"力大无穷",
		"飞檐走壁",
		"外强中干",
		"救死扶伤",
		"固若金汤",
		"身强体壮",
		"铜墙铁壁",
		"杏林高手",
		"生龙活虎",
		"拔山扛鼎"
	}
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[取随机输出门派()],
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = 小怪名称[ygsj(#小怪名称)]
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.1,
			气血 = 阶段属性[等级].气血 * 1.5,
			灵力 = 阶段属性[等级].法伤 * 1.1,
			速度 = 阶段属性[等级].速度 * 0.6,
			防御 = 阶段属性[等级].防御 * 0.25,
			法防 = 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 2.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.4
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.4
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.3
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.35
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.5
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_大王(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 5
	local 数量 = 取随机数(9, 10)
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 小怪名称 = {
		"术精岐黄",
		"铜墙铁壁",
		"力大无穷",
		"飞檐走壁",
		"外强中干",
		"救死扶伤",
		"固若金汤",
		"身强体壮",
		"铜墙铁壁",
		"杏林高手",
		"生龙活虎",
		"拔山扛鼎"
	}
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术[取随机输出门派()],
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			小怪名称[ygsj(#小怪名称)],
			模型库2[ygsj(#模型库2)],
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = 小怪名称[ygsj(#小怪名称)]
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.3,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.3,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.4,
			法防 = 阶段属性[等级].法防 * 0.5,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 4.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.6
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.6
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.55
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.7
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_魑(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.狮驼岭,
			{}
		},
		{
			"魑魅蛇妖",
			"千年蛇魅",
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			"索命海鲛",
			"鲛人",
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"百面伶鬼",
			"地狱战神",
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"浴血火凤",
			"凤凰",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.3,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.4,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.5,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 4.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.6
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.7
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_魅(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.神木林,
			{}
		},
		{
			"白衣秀士",
			"进阶锦毛貂精",
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			"凶神恶煞",
			"律法女娲",
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"行尸走肉",
			"野鬼",
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"碧玉精灵",
			"如意仙子",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.3,
			气血 = 阶段属性[等级].气血 * 2.2,
			灵力 = 阶段属性[等级].法伤 * 1.4,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.4,
			法防 = 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 4.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.6
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.6
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_魍(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.化生寺,
			{
				灵力 = 3
			}
		},
		{
			"暗箭伤人",
			"机关兽",
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			"惑人机关",
			"机关鸟",
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"夺命蛛丝",
			"蜘蛛精",
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"牛气冲天",
			"牛妖",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2.5,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.6
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.7
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_魉(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.天宫,
			{}
		},
		{
			"玉面妖精",
			"雾中仙",
			{
				"夜战"
			},
			夜光随机法术(3),
			{}
		},
		{
			"魔音琵琶",
			"蝎子精",
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"百爪魔灵",
			"百足将军",
			{
				"超级必杀",
				"夜战"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			"伞夜魔仙",
			"蜘蛛精",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.3,
			气血 = 阶段属性[等级].气血 * 2.3,
			灵力 = 阶段属性[等级].法伤 * 1.4,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.5
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.5
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.45
	战斗单位[1].法防 = 阶段属性[等级].法防 * 0.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_鼍龙(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 5
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.龙宫,
			{}
		},
		{
			"双刃魔君",
			"进阶修罗傀儡鬼",
			{
				"夜战"
			},
			Q_门派法术.凌波城,
			{}
		},
		{
			"凶牙猛虎",
			"噬天虎",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.大唐官府,
			{}
		},
		{
			"遁地奇兽",
			"蜃气妖",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.五庄观,
			{}
		},
		{
			"蒙面罗刹",
			"夜罗刹",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		3
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.4,
			气血 = 阶段属性[等级].气血 * 2.5,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1.15,
			防御 = 阶段属性[等级].防御 * 0.5,
			法防 = 阶段属性[等级].法防 * 0.7,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.8
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.8
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].法防 = 阶段属性[等级].法防 * 1
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.65
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_兕怪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.阴曹地府,
			{}
		},
		{
			"致命毒蝎",
			"进阶蝎子精",
			{
				"夜战",
				"超级法术暴击"
			},
			Q_门派法术.魔王寨,
			{}
		},
		{
			"响尾灵蛇",
			"进阶巴蛇",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.化生寺,
			{
				灵力 = 3
			}
		},
		{
			"勾魂修罗",
			"修罗傀儡鬼",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.大唐官府,
			{}
		},
		{
			"掌灯幽灵",
			"幽萤娃娃",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		4,
		5,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2.5,
			灵力 = 阶段属性[等级].法伤 * 1.4,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.7,
			法防 = 阶段属性[等级].法防 * 0.5,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 1.8
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 1.8
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2
	战斗单位[1].法防 = 阶段属性[等级].法防 * 1.3
	战斗单位[1].防御 = 阶段属性[等级].防御 * 0.5
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1.5), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:保卫长安_振威大王(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 10
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称,
			任务数据[任务id].模型,
			{
				"高级夜战",
				"高级感知",
				"必杀",
				"高级连击",
				"法术连击",
				"法术暴击"
			},
			Q_门派法术.狮驼岭,
			{}
		},
		{
			"混世魔童",
			"进阶毗舍童子",
			{
				"夜战",
				"超级法术暴击"
			},
			Q_门派法术.魔王寨,
			{}
		},
		{
			"莲台妖花",
			"进阶曼珠沙华",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.盘丝岭,
			{
				速度 = 3
			}
		},
		{
			"鬼影迷踪",
			"进阶蜃气妖",
			{
				"超级必杀",
				"夜战"
			},
			Q_门派法术.大唐官府,
			{}
		},
		{
			"持杖邪魅",
			"进阶修罗傀儡妖",
			{
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 5,
				法伤减少 = 1.3,
				速度 = 1.5,
				物伤减少 = 0.7
			}
		},
		{
			"诡异巫蝶",
			"进阶蝴蝶仙子",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				速度 = 3
			}
		}
	}
	local 可选 = {
		2,
		4,
		5,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
			怪物名称[i][1] = "妖魔鬼怪"
			怪物名称[i][2] = 模型库2[ygsj(#模型库2)]

			if 判断是否为空表(怪物名称[i][3]) then
				怪物名称[i][3] = 列表2加入到列表1({
					"感知",
					"夜战"
				}, 取低级要诀(3))
			end

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.6,
			气血 = 阶段属性[等级].气血 * 3,
			灵力 = 阶段属性[等级].法伤 * 1.6,
			速度 = 阶段属性[等级].速度 * 1.3,
			防御 = 阶段属性[等级].防御 * 0.55,
			法防 = 阶段属性[等级].法防 * 0.9,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 10,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5.5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 2.2
	战斗单位[1].防御 = 阶段属性[等级].防御 * 1
	战斗单位[1].法防 = 阶段属性[等级].法防 * 1.5
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_子鼠(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	local 数量 = 1
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"感知",
				"烈焰斩",
				"影袭",
				"理直气壮",
				"高级连击",
				"神出鬼没",
				"昼伏夜出",
				"高级必杀",
				"嗜血追击"
			},
			{},
			{
				物伤减少 = 0.5,
				法伤减少 = 1.3,
				开场发言 = "好多人，我要打个洞躲起来#24"
			}
		}
	}
	local 可选 = {
		2,
		4,
		5,
		4
	}

	for n = 1, 数量 do
		local i = n
		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 2.2,
			气血 = 阶段属性[等级].气血 * 10,
			灵力 = 阶段属性[等级].法伤 * 2.5,
			速度 = 阶段属性[等级].速度 * 3,
			防御 = 阶段属性[等级].防御 * 1,
			法防 = 阶段属性[等级].法防 * 1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if k == "开场发言" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].变异 = true
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_丑牛(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 1
	local 数量 = 3
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级法术波动",
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级法术助攻",
				"高级魔法反击",
				"高级法术抵抗",
				"高级魔之心"
			},
			{
				"龙腾",
				"龙卷雨击",
				"双龙戏珠"
			},
			{
				灵力 = 1.5,
				法伤减少 = 0.3,
				速度 = 1.5,
				气血 = 1.5,
				变异 = true
			}
		},
		{
			"哞哞牛",
			"踏云兽",
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀",
				"影袭"
			},
			{},
			{
				物伤减少 = 0.8
			}
		},
		{
			"哞哞牛",
			"踏云兽",
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"影袭"
			},
			{},
			{
				物伤减少 = 0.8
			}
		}
	}
	local 可选 = {
		2,
		4,
		5,
		4
	}

	for n = 1, 数量 do
		local i = n
		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 6,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_寅虎(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 2
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"感知",
				"昼伏夜出",
				"高级必杀",
				"高级进击必杀"
			},
			{
				"横扫千军",
				"破釜沉舟"
			},
			{
				变异 = true,
				速度 = 1.5,
				气血 = 2,
				奇经八脉 = {
					干将 = 1,
					无敌 = 1,
					连破 = 1
				}
			}
		},
		{
			"虎奔",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"虎跑",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"虎跳",
			任务数据[任务id].模型,
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"虎跃",
			任务数据[任务id].模型,
			{
				"夜战"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_卯兔(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 3
	local 数量 = 6
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级魔之心",
				"高级法术助攻",
				"高级魔法反击"
			},
			Q_门派法术.魔王寨,
			{
				变异 = true,
				速度 = 2,
				气血 = 2,
				奇经八脉 = {
					神炎 = 1,
					震怒 = 1
				}
			}
		},
		{
			"蹦蹦",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"跳跳",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"蹦蹦",
			任务数据[任务id].模型,
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"跳跳",
			任务数据[任务id].模型,
			{
				"夜战"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10
			}
		},
		{
			"狸",
			"花妖",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				封印抵抗率 = -9999,
				变异 = true,
				气血 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n
		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.15,
			法防 = 阶段属性[等级].法防 * 0.15,
			躲避 = 阶段属性[等级].伤害 * 8,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_辰龙(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 4
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级必杀",
				"高级进击必杀",
				"高级蛮劲",
				"昼伏夜出",
				"虎虎生风"
			},
			{
				"力劈华山",
				"壁垒击破",
				"舍身一搏"
			},
			{
				法伤减少 = 1.5,
				伤害 = 1.5,
				速度 = 2,
				气血 = 3,
				四系法术吸收概率 = 30,
				变异 = true,
				物伤减少 = 0.5
			}
		},
		{
			"龙飞",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"感知",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"龙跃",
			任务数据[任务id].模型,
			{
				"感知",
				"昼伏夜出",
				"高级必杀",
				"影袭"
			},
			{},
			{}
		},
		{
			"龙飞",
			任务数据[任务id].模型,
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"龙跃",
			任务数据[任务id].模型,
			{
				"超级必杀",
				"夜战"
			},
			{},
			{}
		},
		{
			"龙腾",
			任务数据[任务id].模型,
			{
				"夜战"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		5
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_巳蛇(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 5
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级必杀",
				"高级进击必杀",
				"高级蛮劲",
				"昼伏夜出",
				"虎虎生风"
			},
			Q_门派法术.大唐官府,
			{
				伤害 = 1.5,
				速度 = 1.5,
				气血 = 2,
				变异 = true,
				奇经八脉 = {
					勇念 = 1,
					勇武 = 1
				}
			}
		},
		{
			"蛇形魅影",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀"
			},
			{
				"横扫千军"
			},
			{
				奇经八脉 = {
					勇念 = 1,
					勇武 = 1
				}
			}
		},
		{
			"蛇形魅影",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀"
			},
			{
				"后发制人"
			},
			{
				奇经八脉 = {
					勇武 = 1
				}
			}
		},
		{
			"蛇形魅影",
			任务数据[任务id].模型,
			{
				"高级必杀",
				"夜战"
			},
			{
				"先发制人"
			},
			{
				奇经八脉 = {
					勇武 = 1
				}
			}
		},
		{
			"蛇形魅影",
			任务数据[任务id].模型,
			{
				"夜战"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10
			}
		},
		{
			"狸",
			"花妖",
			{
				"招架",
				"法术抵抗",
				"高级再生"
			},
			夜光随机封印法术(3),
			{
				封印抵抗率 = -9999,
				变异 = true,
				气血 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		2
	}

	for n = 1, 数量 do
		local i = n

		if i > 6 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.2,
			法防 = 阶段属性[等级].法防 * 0.2,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_午马(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 6
	local 数量 = 8
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"超级必杀",
				"高级进击必杀",
				"高级蛮劲",
				"昼伏夜出",
				"虎虎生风"
			},
			{},
			{
				变异 = true,
				伤害 = 1.5,
				速度 = 1.5,
				气血 = 1.5
			}
		},
		{
			"追风",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀"
			},
			{},
			{}
		},
		{
			"逐日",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀"
			},
			{},
			{}
		},
		{
			"追风",
			任务数据[任务id].模型,
			{
				"高级法术暴击",
				"高级法术连击",
				"夜战"
			},
			{
				"奔雷咒",
				"泰山压顶",
				"地狱烈火"
			},
			{}
		},
		{
			"逐日",
			任务数据[任务id].模型,
			{
				"溜之大吉"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_未羊(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 7
	local 数量 = 3
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级必杀",
				"超级反震",
				"高级蛮劲",
				"昼伏夜出",
				"高级反击"
			},
			五行法术列表,
			{
				变异 = true,
				伤害 = 1.5,
				速度 = 1.5,
				气血 = 2
			}
		},
		{
			"咩咩",
			任务数据[任务id].模型,
			{
				"昼伏夜出",
				"高级感知",
				"高级必杀",
				"高级反震"
			},
			五行法术列表,
			{}
		},
		{
			"咩咩",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级反震"
			},
			五行法术列表,
			{}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.4,
			法防 = 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_申猴(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 8
	local 数量 = 1
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"嗜血追击",
				"高级感知",
				"高级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"高级偷袭",
				"昼伏夜出",
				"高级反击",
				"高级连击",
				"理直气壮"
			},
			五行法术列表,
			{
				气血 = 2,
				伤害 = 2,
				速度 = 2,
				发言 = "#18我就喜欢挑战防御高的人……",
				连击 = 100,
				变异 = true,
				穿刺等级 = 500
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 2,
			气血 = 阶段属性[等级].气血 * 15,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.25,
			法防 = 阶段属性[等级].法防 * 0.25,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_酉鸡(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 9
	local 数量 = 6
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"高级法术暴击",
				"高级法术穿透",
				"高级魔之心",
				"高级魔法反击",
				"高级法术连击",
				"高级报复",
				"高级法术波动"
			},
			{
				"超级奔雷咒"
			},
			{
				灵力 = 1.5,
				变异 = true,
				速度 = 1.5,
				气血 = 2
			}
		},
		{
			"鸡鸣",
			任务数据[任务id].模型,
			{
				"感知",
				"法术暴击",
				"法术穿透",
				"魔之心",
				"魔法反击",
				"法术连击",
				"高级报复",
				"高级法术波动"
			},
			{
				"奔雷咒"
			},
			{}
		},
		{
			"鸡鸣",
			任务数据[任务id].模型,
			{
				"感知",
				"法术暴击",
				"法术穿透",
				"魔之心",
				"魔法反击",
				"法术连击",
				"高级报复",
				"高级法术波动"
			},
			{
				"奔雷咒"
			},
			{}
		},
		{
			"鸡鸣",
			任务数据[任务id].模型,
			{
				"感知",
				"法术暴击",
				"法术穿透",
				"魔之心",
				"魔法反击",
				"法术连击",
				"高级报复",
				"高级法术波动"
			},
			{
				"奔雷咒"
			},
			{}
		},
		{
			"报晓",
			任务数据[任务id].模型,
			{
				"溜之大吉"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10,
				气血 = 1.3
			}
		},
		{
			"狸",
			"花妖",
			{
				"招架",
				"法术抵抗",
				"超级再生"
			},
			夜光随机封印法术(3),
			{
				封印抵抗率 = -9999,
				变异 = true,
				气血 = 10
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 2,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_戌犬(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 10
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{
				变异 = true,
				速度 = 2,
				气血 = 2.5
			}
		},
		{
			"犬吠",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{}
		},
		{
			"犬吠",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{}
		},
		{
			"犬吠",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{}
		},
		{
			"犬吠",
			任务数据[任务id].模型,
			{
				"溜之大吉"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 10,
				气血 = 1.3
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 2,
			气血 = 阶段属性[等级].气血 * 4,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:天降星辰_亥猪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id) + 11
	local 数量 = 10
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[5] = 夜光随机恢复法术
	}
	local 怪物名称 = {
		{
			任务数据[任务id].名称 .. "分身",
			任务数据[任务id].模型,
			{
				"超级再生",
				"高级神佑复生",
				"高级感知",
				"昼伏夜出",
				"超级必杀",
				"超级连击",
				"影袭",
				"吸血",
				"理直气壮"
			},
			{},
			{
				气血 = 2,
				法伤减少 = 0.4,
				速度 = 2,
				发言 = "吃饭、睡觉、回回血……#86",
				变异 = true,
				物伤减少 = 0.2
			}
		},
		{
			"猪小哼",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{
				法伤减少 = 0.5,
				物伤减少 = 0.5
			}
		},
		{
			"哼哼猪",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{
				法伤减少 = 0.3
			}
		},
		{
			"猪哼哼",
			任务数据[任务id].模型,
			{
				"高级感知",
				"昼伏夜出",
				"高级必杀",
				"高级连击",
				"影袭"
			},
			{},
			{
				物伤减少 = 0.3
			}
		},
		{
			"猪猪猪",
			任务数据[任务id].模型,
			{
				"溜之大吉"
			},
			夜光随机恢复法术(3),
			{
				灵力 = 20,
				气血 = 2
			}
		}
	}
	local 可选 = {
		2,
		3,
		4
	}

	for n = 1, 数量 do
		local i = n

		if i > 5 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]
		end

		战斗单位[n] = {
			愤怒 = 99999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.35,
			法防 = 阶段属性[等级].法防 * 0.35,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 2)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				if type(v) ~= "number" then
					战斗单位[n][k] = v
				else
					战斗单位[n][k] = (战斗单位[n][k] or 1) * v
				end
			end
		end
	end

	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 1), 5)
	战斗单位[1].不可封印 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:雁塔地宫信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz1(取队伍最高等级数(玩家数据[玩家id].队伍, 玩家id) / 10) * 10
	local 层数 = 雁塔地宫:取地宫最低层数(玩家id)
	local 属性递增 = {
		气血 = 层数 * 等级 * 20,
		伤害 = qz(层数 * 等级 / 4),
		法伤 = qz(层数 * 等级 / 7),
		速度 = qz(层数 * 等级 / 10),
		封印 = qz(层数 * 等级 / 20),
		固伤 = qz(层数 * 等级 / 5),
		治疗 = qz(层数 * 等级 / 5),
		防御 = qz(层数 * 等级 / 5),
		法防 = qz(层数 * 等级 / 7)
	}
	local gw = 雁塔地宫.取怪物[层数]
	local 门派 = gw[1].QT.门派
	local sx = 阶段属性[等级]
	战斗单位[1] = {
		愤怒 = 9999,
		主怪 = true,
		名称 = gw[1].名称,
		模型 = gw[1].模型,
		不可封印 = gw[1].不可封印,
		等级 = 等级,
		气血 = qz((sx.气血 * 1.5 + 属性递增.气血) * gw[1].额外面板百分比.气血),
		伤害 = qz((sx.伤害 * 1.5 + 属性递增.伤害) * gw[1].额外面板百分比.伤害),
		灵力 = qz((sx.法伤 * 1.5 + 属性递增.法伤) * gw[1].额外面板百分比.法伤),
		速度 = qz((sx.速度 * 2 + 属性递增.速度) * gw[1].额外面板百分比.速度),
		固定伤害 = qz((等级 * 3 + 属性递增.固伤) * gw[1].额外面板百分比.固定伤害),
		治疗能力 = qz((等级 * 4 + 属性递增.治疗) * gw[1].额外面板百分比.治疗能力),
		封印命中等级 = qz((100 + 属性递增.封印) * gw[1].额外面板百分比.封印命中等级),
		抵抗封印等级 = qz(-50 * gw[1].额外面板百分比.抵抗封印等级),
		受伤百分比 = gw[1].额外面板百分比.受伤百分比,
		增伤百分比 = gw[1].额外面板百分比.增伤百分比,
		物伤免疫 = gw[1].额外面板百分比.物伤免疫,
		法伤免疫 = gw[1].额外面板百分比.法伤免疫,
		防御 = qz(等级 * 8 + 属性递增.防御),
		法防 = qz(等级 * 6 + 属性递增.法防),
		躲避 = sx.伤害 / 2,
		魔法 = sx.魔法 * 10,
		变异 = gw[1].QT.变异,
		显示饰品 = gw[1].QT.饰品,
		染色方案 = gw[1].QT.染色方案,
		染色组 = gw[1].QT.染色组,
		前缀 = gw[1].前缀,
		后缀 = gw[1].后缀,
		层数 = 层数,
		技能 = gw[1].QT.被动技能,
		主动技能 = gw[1].QT.主动技能,
		门派 = gw[1].QT.门派
	}

	for n = 2, #gw do
		门派 = gw[n].QT.门派
		战斗单位[n] = {
			愤怒 = 9999,
			名称 = gw[n].名称,
			模型 = gw[n].模型,
			不可封印 = gw[n].不可封印,
			防御 = qz(等级 * 6 + 属性递增.防御),
			法防 = qz(等级 * 5 + 属性递增.法防),
			等级 = 等级,
			躲避 = sx.伤害 / 2,
			魔法 = sx.魔法 * 10,
			气血 = qz((sx.气血 * 1.2 + 属性递增.气血) * gw[n].额外面板百分比.气血),
			伤害 = qz((sx.伤害 * 1.2 + 属性递增.伤害) * gw[n].额外面板百分比.伤害),
			灵力 = qz((sx.法伤 * 1.2 + 属性递增.法伤) * gw[n].额外面板百分比.法伤),
			速度 = qz((sx.速度 * 1.2 + 属性递增.速度) * gw[n].额外面板百分比.速度),
			固定伤害 = qz((等级 * 2.5 + 属性递增.固伤) * gw[n].额外面板百分比.固定伤害),
			治疗能力 = qz((等级 * 3 + 属性递增.治疗) * gw[n].额外面板百分比.治疗能力),
			封印命中等级 = qz((80 + 属性递增.封印) * gw[n].额外面板百分比.封印命中等级),
			抵抗封印等级 = qz(-100 * gw[n].额外面板百分比.抵抗封印等级),
			受伤百分比 = gw[n].额外面板百分比.受伤百分比,
			增伤百分比 = gw[n].额外面板百分比.增伤百分比,
			物伤免疫 = gw[n].额外面板百分比.物伤免疫,
			法伤免疫 = gw[n].额外面板百分比.法伤免疫,
			变异 = gw[n].QT.变异,
			显示饰品 = gw[n].QT.饰品,
			染色方案 = gw[n].QT.染色方案,
			染色组 = gw[n].QT.染色组,
			前缀 = gw[n].前缀,
			后缀 = gw[n].后缀,
			层数 = 层数,
			技能 = gw[n].QT.被动技能,
			主动技能 = gw[n].QT.主动技能,
			门派 = gw[n].QT.门派
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取对应宠物1(任务id, 玩家id)
	local mc = "幽灵虎"
	local 战斗单位 = {}
	local 等级 = 60
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"破血狂攻"
			}, Q_门派法术.大唐官府),
			{}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.5
	战斗单位[1].法伤减少 = 1.8

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取对应宠物2(任务id, 玩家id)
	local mc = "玄武"
	local 战斗单位 = {}
	local 等级 = 70
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级法术连击",
				"高级魔之心",
				"高级法术穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"法术防御"
			}, Q_门派法术.龙宫),
			{}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.8
	战斗单位[1].法伤减少 = 0.8

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取对应宠物3(任务id, 玩家id)
	local mc = "剑魂"
	local 战斗单位 = {}
	local 等级 = 80
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"剑气四射·觉醒",
				"剑荡四方",
				"破血狂攻"
			}, Q_门派法术.大唐官府),
			{}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.9
	战斗单位[1].法伤减少 = 1.1

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取对应宠物4(任务id, 玩家id)
	local mc = "龙剑女"
	local 战斗单位 = {}
	local 等级 = 80
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			取宝宝(mc)[9],
			{
				"剑气四射·觉醒",
				"善恶有报",
				"横扫千军"
			}
		},
		{
			mc,
			mc,
			取高级要诀(3),
			取随机法术(2)
		},
		{
			mc,
			mc,
			取高级要诀(3),
			取随机法术(2)
		},
		{
			mc,
			mc,
			取高级要诀(3),
			取随机法术(2)
		},
		{
			mc,
			mc,
			取高级要诀(3),
			取随机法术(2)
		}
	}
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"剑气四射·觉醒",
				"善恶有报",
				"横扫千军"
			}, Q_门派法术.五庄观),
			{}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.5
	战斗单位[1].法伤减少 = 1.5

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取对应宠物5(任务id, 玩家id)
	local mc = "法僧"
	local 战斗单位 = {}
	local 等级 = 90
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级法术连击",
				"高级魔之心",
				"高级法术穿透",
				"高级报复"
			},
			{
				"龙卷雨击",
				"唧唧歪歪",
				"推气过宫"
			},
			{
				法防 = 1.3,
				防御 = 1.3
			}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 1.3
	战斗单位[1].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取对应宠物6(任务id, 玩家id)
	local mc = "死亡骑士"
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"舍身一搏"
			}, Q_门派法术.狮驼岭),
			{}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 5
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.8
	战斗单位[1].法伤减少 = 1.3

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取对应宠物7(任务id, 玩家id)
	local mc = "齐天小圣"
	local 战斗单位 = {}
	local 等级 = 100
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"双星闪",
				"烟雨剑法"
			}, Q_门派法术.天宫),
			{
				法防 = 0.8,
				防御 = 1.5
			}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 7
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 0.5
	战斗单位[1].法伤减少 = 1.8

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取对应宠物8(任务id, 玩家id)
	local mc = "魔化毗舍童子"
	local 战斗单位 = {}
	local 等级 = 110
	战斗单位.阵法 = 阵法名称[取随机数(2, #阵法名称)]
	local 位置 = {
		[2] = 夜光随机法术,
		[4] = 夜光随机物理法术,
		[7] = 夜光随机恢复法术,
		[6] = 夜光随机封印法术
	}
	local 怪物名称 = {
		{
			mc .. "统领",
			mc,
			{
				"高级感知",
				"高级夜战",
				"高级神佑复生",
				"高级必杀",
				"高级蛮劲",
				"高级物理穿透",
				"高级报复"
			},
			列表2加入到列表1({
				"破血狂攻"
			}, Q_门派法术.大唐官府),
			{
				防御 = 1.5
			}
		},
		{
			mc .. "法师",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机法术(3),
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"高级连击",
				"必杀",
				"高级夜战",
				"神佑复生",
				"蛮劲"
			},
			{},
			{}
		},
		{
			mc .. "战士",
			mc,
			{
				"必杀",
				"夜战",
				"神佑复生"
			},
			夜光随机物理法术(3),
			{}
		},
		{
			mc .. "阴魂",
			mc,
			{
				"高级鬼魂术",
				"高级法术抵抗",
				"高级防御",
				"高级招架"
			},
			夜光随机固伤法术(3),
			{
				固伤加成 = 0.5
			}
		},
		{
			mc .. "巫师",
			mc,
			{
				"高级招架",
				"高级法术抵抗",
				"高级再生",
				"敏捷",
				"神佑复生"
			},
			夜光随机封印法术(3),
			{
				速度 = 2
			}
		},
		{
			mc .. "巫医",
			mc,
			{
				"法术连击",
				"夜战",
				"法术暴击",
				"法术波动",
				"神佑复生"
			},
			夜光随机恢复法术(3),
			{
				速度 = 1.5,
				灵力 = 1.5
			}
		}
	}
	local 可选 = {
		2,
		3,
		4,
		6,
		7
	}

	for n = 1, 10 do
		local i = n

		if i > 7 then
			local aa = ygsj(#可选)
			local bb = 可选[aa]
			怪物名称[i] = 怪物名称[bb]

			if 位置[bb] == nil then
				怪物名称[i][4] = {}
			else
				怪物名称[i][4] = 位置[bb](3)
			end

			table.remove(可选, aa)
		end

		战斗单位[n] = {
			愤怒 = 9999,
			变异 = false,
			名称 = 怪物名称[i][1],
			模型 = 怪物名称[i][2],
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 怪物名称[i][3],
			主动技能 = 怪物名称[i][4],
			攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1),
			抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 3), 1)
		}

		if not 判断是否为空表(怪物名称[i][5]) then
			for k, v in pairs(怪物名称[i][5]) do
				战斗单位[n][k] = (战斗单位[n][k] or 1) * v
			end
		end
	end

	战斗单位[1].气血 = 阶段属性[等级].气血 * 6
	战斗单位[1].伤害 = 阶段属性[等级].伤害 * 2
	战斗单位[1].灵力 = 阶段属性[等级].法伤 * 2
	战斗单位[1].速度 = 阶段属性[等级].速度 * 1.6
	战斗单位[1].攻击修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].防御修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].法术修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].抗法修炼 = math.max(qz1(阶段属性[等级].修炼 / 2), 1)
	战斗单位[1].不可封印 = true
	战斗单位[1].变异 = true
	战斗单位[1].物伤减少 = 1.5
	战斗单位[1].法伤减少 = 1.5

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取副本芭蕉妖怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	for n = 1, 8 do
		战斗单位[n] = {
			魔法 = 99999900,
			模型 = "树怪",
			名称 = "伙伴木妖",
			伤害 = 等级 * 5,
			气血 = 等级 * 10,
			灵力 = 等级 * 4,
			速度 = 等级 * 1,
			防御 = 等级 * 0.8,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(2)
		}
	end

	战斗单位[1].名称 = "芭蕉木妖"
	战斗单位[1].变异 = true

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取迷宫小怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 技能 = {}
	local aa, bb = nil

	if 任务id == nil then
		aa = "迷宫小怪"
		bb = 模型库2[取随机数(1, #模型库2)]
	else
		aa = 任务数据[任务id].名称
		bb = 任务数据[任务id].模型
	end

	战斗单位[1] = {
		愤怒 = 9999,
		名称 = aa,
		模型 = bb,
		气血 = 阶段属性[等级].气血 * 0.9,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 0.9,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		等级 = 等级,
		技能 = 取高级要诀(3),
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		主动技能 = {
			"水攻",
			"烈火",
			"雷击",
			"落岩"
		}
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 取随机数(取队伍人数(玩家id), 取队伍人数(玩家id) * 2 - 1)

	if 数量 > 9 then
		数量 = 9
	end

	for n = 1, 数量 do
		local 模型 = 取随机怪(0, 等级 + 10)
		战斗单位[n + 1] = {
			愤怒 = 9999,
			名称 = "迷宫小怪",
			模型 = 模型[2],
			气血 = 阶段属性[等级].气血 * 0.55,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.8,
			灵力 = 阶段属性[等级].法伤 * 0.9,
			速度 = 阶段属性[等级].速度 * 0.5,
			防御 = 阶段属性[等级].防御 * 0.05,
			法防 = 阶段属性[等级].法防 * 0.05,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 取低级要诀(3),
			主动技能 = 取随机法术(2)
		}
	end

	return 全局战斗难度调整(战斗单位, 0.9)
end

function 战斗准备类:取副本鬼祟小怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	for n = 1, 5 do
		local 模型 = 取随机怪(10, 20)
		战斗单位[n] = {
			魔法 = 99999900,
			名称 = "鬼祟小怪",
			模型 = 模型[2],
			伤害 = 等级 * 5,
			气血 = 等级 * 50,
			灵力 = 等级 * 4,
			速度 = 等级 * 1,
			防御 = 等级 * 0.8,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {}
		}
	end

	战斗单位[1].模型 = 任务数据[任务id].模型

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:自动官职(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5

	for n = 1, 2 do
		战斗单位[n] = {
			魔法 = 99999900,
			法防 = 10,
			模型 = "强盗",
			名称 = "突厥奸细",
			伤害 = 等级 * 6,
			气血 = 等级 * 15,
			灵力 = 等级 * 4,
			速度 = 等级 * 1,
			防御 = 等级 * 0.5,
			躲避 = 等级 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:自动门派(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5

	for n = 1, 2 do
		local 模型 = 取随机怪(1, 等级)
		战斗单位[n] = {
			魔法 = 99999900,
			名称 = "捣乱的" .. 模型[2],
			模型 = 模型[2],
			伤害 = 等级 * 5,
			气血 = 等级 * 等级 * 0.65,
			灵力 = 等级 * 1,
			速度 = 等级 * 1.5,
			防御 = 等级 * 4,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(3)
		}
	end

	战斗单位[2].名称 = 战斗单位[2].模型 .. "帮凶"

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取梦靥夜叉(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}
	阵容.怪物数据[1] = {
		伤害 = 0.7,
		愤怒 = 9999,
		气血 = 1.5,
		法防 = 0.1,
		变异 = true,
		魔法 = 10,
		躲避 = 1,
		法伤 = 0.7,
		速度 = 1,
		防御 = 0.1,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		修炼 = {},
		被动技能 = {
			"高级健壮",
			"敏捷"
		},
		主动技能 = {}
	}
	local aa = ygsj()

	if aa <= 33 then
		阵容.怪物数据[1].特殊标记 = "画魂"
		阵容.怪物数据[1].发言 = "有本事就把喽啰换成同一种类型#28"
		local 模型 = "画魂"
		local 名称 = "画魂夜叉"

		for i = 2, 10 do
			if i == 3 then
				模型 = "幽萤娃娃"
				名称 = "幽萤夜叉"
			elseif i > 3 then
				if ygsj() <= 50 then
					模型 = "幽萤娃娃"
					名称 = "幽萤夜叉"
				else
					模型 = "画魂"
					名称 = "画魂夜叉"
				end
			end

			阵容.怪物数据[i] = {
				伤害 = 0.3,
				愤怒 = 9999,
				气血 = 0.15,
				法防 = 0.1,
				魔法 = 10,
				躲避 = 1,
				不攻击 = 1,
				法伤 = 0.3,
				速度 = 0.1,
				防御 = 0.1,
				名称 = 名称,
				模型 = 模型,
				修炼 = {},
				被动技能 = {
					"夜战",
					"必杀",
					"连击",
					"法术连击",
					"法术暴击"
				},
				主动技能 = {}
			}
		end
	elseif aa <= 66 then
		阵容.怪物数据[1].特殊标记 = "龙龟"
		阵容.怪物数据[1].发言 = "带有宝贝的不要露脸了，小心宝贝被他们抢走！"

		for i = 2, 6 do
			阵容.怪物数据[i] = {
				伤害 = 0.3,
				愤怒 = 9999,
				气血 = 0.15,
				法防 = 0.1,
				魔法 = 10,
				躲避 = 1,
				不攻击 = 1,
				法伤 = 0.3,
				速度 = 0.1,
				模型 = "龙龟",
				名称 = "神气灵龟",
				防御 = 0.1,
				修炼 = {},
				被动技能 = {
					"夜战",
					"必杀",
					"连击",
					"法术连击",
					"法术暴击"
				},
				主动技能 = {}
			}
		end
	else
		阵容.怪物数据[1].特殊标记 = "厉鬼"

		for i = 2, 10 do
			阵容.怪物数据[i] = {
				伤害 = 0.3,
				愤怒 = 9999,
				气血 = 0.15,
				法防 = 0.1,
				魔法 = 10,
				躲避 = 1,
				法伤 = 0.3,
				速度 = 0.1,
				名称 = "万年厉鬼",
				防御 = 0.1,
				模型 = 取随机怪(10, 55)[2],
				修炼 = {},
				被动技能 = {
					"夜战",
					"必杀",
					"连击",
					"法术连击",
					"法术暴击"
				},
				主动技能 = {}
			}
		end
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取鬼王任务信息(任务id, id)
	local 阵容 = {
		怪物数据 = {},
		等级 = 取队伍平均等级(玩家数据[id].队伍, id)
	}

	if 任务数据[任务id].模型 == "吸血鬼" then
		阵容.怪物数据[1] = {
			伤害 = 1,
			愤怒 = 9999,
			气血 = 4,
			魔法 = 20,
			躲避 = 1,
			法防 = 0.35,
			法伤 = 2.5,
			速度 = 1,
			防御 = 0.35,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			修炼 = {
				0.5,
				0.5,
				0.5,
				0.5
			},
			其他属性 = {
				固伤加成 = 0.5
			},
			被动技能 = {
				"高级鬼魂术",
				"夜战",
				"必杀"
			},
			主动技能 = {
				"阎罗令",
				"地涌金莲",
				"推拿",
				"雨落寒沙"
			}
		}
	elseif 任务数据[任务id].模型 == "鬼将" then
		阵容.怪物数据[1] = {
			伤害 = 1.4,
			愤怒 = 9999,
			气血 = 1.8,
			魔法 = 20,
			躲避 = 1,
			法防 = 0.35,
			法伤 = 1,
			速度 = 1.5,
			防御 = 0.35,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			修炼 = {
				0.5,
				0.5,
				0.5,
				0.5
			},
			其他属性 = {
				物伤减少 = 0.35
			},
			被动技能 = {
				"高级夜战",
				"高级必杀",
				"高级连击"
			},
			主动技能 = {
				"横扫千军",
				"后发制人",
				"破血狂攻",
				"烟雨剑法",
				"剑荡四方",
				"剑气四射",
				"弱点击破",
				"善恶有报"
			}
		}
	elseif 任务数据[任务id].模型 == "夜罗刹" then
		阵容.怪物数据[1] = {
			伤害 = 1,
			愤怒 = 9999,
			气血 = 1.8,
			魔法 = 20,
			躲避 = 1,
			法防 = 0.35,
			法伤 = 1.6,
			速度 = 1.2,
			防御 = 0.35,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			修炼 = {
				0.5,
				0.5,
				0.5,
				0.5
			},
			其他属性 = {
				法伤减少 = 0.35
			},
			被动技能 = {
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 夜光随机法术(5)
		}
	elseif 任务数据[任务id].模型 == "炎魔神" then
		阵容.怪物数据[1] = {
			伤害 = 1.1,
			愤怒 = 9999,
			气血 = 0.8,
			魔法 = 20,
			躲避 = 1,
			法防 = 0.5,
			法伤 = 1,
			速度 = 1.2,
			防御 = 0.5,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			修炼 = {
				0.5,
				0.5,
				0.5,
				0.5
			},
			其他属性 = {
				法伤减少 = 0.1,
				物伤减少 = 0.1
			},
			被动技能 = {
				"高级夜战",
				"高级必杀",
				"高级连击"
			},
			主动技能 = {}
		}
	elseif 任务数据[任务id].模型 == "幽灵" then
		阵容.怪物数据[1] = {
			伤害 = 1.1,
			愤怒 = 9999,
			气血 = 2,
			法防 = 0.35,
			魔法 = 20,
			躲避 = 3,
			法伤 = 1.2,
			速度 = 1.2,
			防御 = 0.35,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			修炼 = {
				0.5,
				0.5,
				0.5,
				0.5
			},
			被动技能 = {
				"高级夜战",
				"高级必杀",
				"高级连击",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = Q_门派法术[门派名称[ygsj(#门派名称)]]
		}
	end

	for i = 2, 6 + ygsj(4) do
		local aa = ygsj()
		local 主动技能 = {}

		if aa <= 33 then
			主动技能 = {}
		elseif aa <= 66 then
			主动技能 = 夜光随机物理法术(3)
		else
			主动技能 = 夜光随机法术(3)
		end

		阵容.怪物数据[i] = {
			伤害 = 0.8,
			愤怒 = 9999,
			气血 = 0.7,
			法防 = 0.2,
			魔法 = 10,
			躲避 = 0.5,
			法伤 = 0.9,
			速度 = 0.5,
			名称 = "厉鬼帮凶",
			防御 = 0.2,
			模型 = 取随机怪(45, 阵容.等级)[2],
			修炼 = {},
			被动技能 = {
				"夜战",
				"必杀",
				"连击",
				"法术连击",
				"法术暴击"
			},
			主动技能 = 主动技能
		}
	end

	return 战斗数据标准模板(阵容, id, 任务id)
end

function 战斗准备类:取捉鬼任务信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 血量加成 = 1
	local 法伤减少 = 1
	local 物伤减少 = 1
	local 速度加成 = 1
	local 普攻躲避率 = 0

	if 任务数据[任务id].模型 == "马面" then
		血量加成 = 1.6
		法伤减少 = 0.35
	elseif 任务数据[任务id].模型 == "牛头" then
		血量加成 = 1.6
		物伤减少 = 0.35
	elseif 任务数据[任务id].模型 == "野鬼" then
		物伤减少 = 0.1
		法伤减少 = 0.1
		血量加成 = 0.45
		速度加成 = 0.3
	elseif 任务数据[任务id].模型 == "骷髅怪" then
		普攻躲避率 = 50
		血量加成 = 2.5
	elseif 任务数据[任务id].模型 == "僵尸" then
		血量加成 = 3.5
	end

	战斗单位[1] = {
		愤怒 = 9999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		气血 = 阶段属性[等级].气血 * 1 * 血量加成,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 0.7,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 1 * 速度加成,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		普攻躲避率 = 普攻躲避率,
		物伤减少 = 物伤减少,
		法伤减少 = 法伤减少,
		等级 = 等级,
		技能 = 取高级要诀(3),
		主动技能 = 夜光随机攻击法术(5)
	}
	local 数量 = 取随机数(5, 8)

	for n = 1, 数量 do
		local 模型 = 取随机怪(任务数据[任务id].等级, 任务数据[任务id].等级)
		战斗单位[n + 1] = {
			愤怒 = 9999,
			名称 = 模型[2] .. "恶鬼",
			模型 = 模型[2],
			气血 = 阶段属性[等级].气血 * 0.35,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.3,
			防御 = 阶段属性[等级].防御 * 0.1,
			法防 = 阶段属性[等级].法防 * 0.1,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 取低级要诀(3),
			主动技能 = 取随机法术(2)
		}
	end

	if 取随机数() <= 2 then
		战斗单位[#战斗单位] = {
			魔法 = 99999900,
			捉鬼变异 = true,
			变异 = true,
			伤害 = 1,
			名称 = "善良的" .. 任务数据[任务id].模型,
			模型 = 任务数据[任务id].模型,
			气血 = 等级 * 等级 * 0.25 + 500,
			灵力 = 等级 * 4,
			速度 = 等级 * 3,
			防御 = 等级,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 2,
			等级 = 等级,
			技能 = 取低级要诀(3),
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:自动抓鬼(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 血量加成 = 1
	local 法伤减少 = 1
	local 物伤减少 = 1
	local 速度加成 = 1
	local 普攻躲避率 = 0
	local 捉鬼模型列表 = {
		"马面",
		"牛头",
		"野鬼",
		"骷髅怪",
		"僵尸"
	}
	local 捉鬼模型 = 捉鬼模型列表[ygsj(#捉鬼模型列表)]

	if 捉鬼模型 == "马面" then
		血量加成 = 2.8
		法伤减少 = 0.35
	elseif 捉鬼模型 == "牛头" then
		血量加成 = 1.5
		物伤减少 = 0.35
	elseif 捉鬼模型 == "野鬼" then
		物伤减少 = 0.1
		法伤减少 = 0.1
		血量加成 = 0.45
		速度加成 = 0.3
	elseif 捉鬼模型 == "骷髅怪" then
		普攻躲避率 = 50
		血量加成 = 1.6
	elseif 捉鬼模型 == "僵尸" then
		血量加成 = 3.5
	end

	local 时辰库 = {
		"子",
		"丑",
		"寅",
		"卯",
		"辰",
		"巳",
		"午",
		"未",
		"申",
		"酉",
		"戌",
		"亥"
	}
	local 时刻库 = {
		"一",
		"二",
		"三",
		"四",
		"五",
		"六"
	}
	local 鬼名库 = {
		"诌鬼",
		"假鬼",
		"奸鬼",
		"捣蛋鬼",
		"冒失鬼",
		"烟沙鬼",
		"挖渣鬼",
		"仔细鬼",
		"讨吃鬼",
		"醉死鬼",
		"抠掏鬼",
		"伶俐鬼",
		"急突鬼",
		"丢谎鬼",
		"乜斜鬼",
		"撩桥鬼",
		"饿鬼",
		"色鬼",
		"穷鬼",
		"刻山鬼",
		"吸血鬼",
		"惊鸿鬼",
		"清明鬼"
	}
	local 鬼名称 = 时辰库[取随机数(1, #时辰库)] .. "时" .. 时刻库[取随机数(1, #时刻库)] .. "刻" .. 鬼名库[取随机数(1, #鬼名库)]
	战斗单位[1] = {
		愤怒 = 9999,
		名称 = 鬼名称,
		模型 = 捉鬼模型,
		气血 = 阶段属性[等级].气血 * 1 * 血量加成,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 0.7,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 1 * 速度加成,
		防御 = 阶段属性[等级].防御 * 0.1,
		法防 = 阶段属性[等级].法防 * 0.1,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		普攻躲避率 = 普攻躲避率,
		物伤减少 = 物伤减少,
		法伤减少 = 法伤减少,
		等级 = 等级,
		技能 = 取高级要诀(3),
		主动技能 = 取随机法术(2)
	}
	local 数量 = 取随机数(5, 8)

	for n = 1, 数量 do
		local 模型 = 取随机怪(0, 155)
		战斗单位[n + 1] = {
			愤怒 = 9999,
			名称 = 模型[2] .. "恶鬼",
			模型 = 模型[2],
			气血 = 阶段属性[等级].气血 * 0.35,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 0.6,
			速度 = 阶段属性[等级].速度 * 0.3,
			防御 = 阶段属性[等级].防御 * 0.05,
			法防 = 阶段属性[等级].法防 * 0.05,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 取低级要诀(3),
			主动技能 = 取随机法术(2)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取宝图强盗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz1(math.max(玩家数据[玩家id].角色.数据.等级 / 10, 1)) * 10
	战斗单位[1] = {
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 2,
		等级 = 等级,
		技能 = 取低级要诀(3),
		主动技能 = 取随机法术(2)
	}
	local bs = 模型库1[取随机数(1, #模型库1)]
	战斗单位[2] = {
		名称 = bs .. "帮手",
		模型 = bs,
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.5,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 2,
		等级 = 等级,
		技能 = 取低级要诀(3),
		主动技能 = {}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取宠修战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 次数 = 任务数据[任务id].次数
	local 伤害系数 = 次数 * 0.01 + 1
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		愤怒 = 9999,
		名称 = 任务数据[任务id].名称 .. "麾下大将",
		模型 = 模型库1[取随机数(1, #模型库1)],
		气血 = 阶段属性[等级].气血 * 1 * 伤害系数,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 0.7 * 伤害系数,
		灵力 = 阶段属性[等级].法伤 * 0.8 * 伤害系数,
		速度 = 阶段属性[等级].速度 * 1 * 伤害系数,
		防御 = 阶段属性[等级].防御 * 0.1 * 伤害系数,
		法防 = 阶段属性[等级].法防 * 0.1 * 伤害系数,
		躲避 = 阶段属性[等级].躲避 * 0.5 * 伤害系数,
		等级 = 等级,
		技能 = {
			"高级必杀",
			"高级法术暴击",
			"高级法术连击",
			"高级感知",
			"高级反击"
		},
		主动技能 = 取随机法术(3)
	}
	local 数量 = 取随机数(1, 2)
	等级 = 等级 - 3

	for n = 1, 数量 do
		local 模型1 = 模型库2[取随机数(1, #模型库2)]
		战斗单位[n + 1] = {
			愤怒 = 9999,
			名称 = 模型1 .. "帮手",
			模型 = 模型1,
			气血 = 阶段属性[等级].气血 * 0.8 * 伤害系数,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.7 * (1 + (伤害系数 - 1) / 2),
			灵力 = 阶段属性[等级].法伤 * 0.8 * (1 + (伤害系数 - 1) / 2),
			速度 = 阶段属性[等级].速度 * 0.8 * (1 + (伤害系数 - 1) / 2),
			防御 = 阶段属性[等级].防御 * 0.1 * (1 + (伤害系数 - 1) / 2),
			法防 = 阶段属性[等级].法防 * 0.1 * (1 + (伤害系数 - 1) / 2),
			躲避 = 阶段属性[等级].躲避 * 0.5 * (1 + (伤害系数 - 1) / 2),
			等级 = 等级,
			技能 = {
				"高级必杀",
				"连击",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = 列表2加入到列表1({
				"舍身一搏"
			}, {
				四系法术列表[ygsj(#四系法术列表)]
			})
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取地煞信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 伤害系数 = 1
	local 气血系数, 灵力系数, 速度系数, 法防系数, 防御系数 = nil
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 难度等级 = 1
	local 怪物数量 = 10

	if 任务数据[任务id].名称 == "初出茅庐地煞星" then
		伤害系数 = 0.9
		气血系数 = 0.9
		灵力系数 = 0.9
		速度系数 = 0.5
		法防系数 = 0.9
		防御系数 = 0.9
		难度等级 = 1
		怪物数量 = 6
	elseif 任务数据[任务id].名称 == "小有所成地煞星" then
		伤害系数 = 1
		气血系数 = 1.3
		灵力系数 = 1
		速度系数 = 0.6
		法防系数 = 1.2
		防御系数 = 1.2
		难度等级 = 2
		怪物数量 = 8
	elseif 任务数据[任务id].名称 == "伏虎斩妖地煞星" then
		伤害系数 = 1.2
		气血系数 = 1.8
		灵力系数 = 1.2
		速度系数 = 0.75
		法防系数 = 1.5
		防御系数 = 1.5
		难度等级 = 3
	elseif 任务数据[任务id].名称 == "御风神行地煞星" then
		伤害系数 = 1.3
		气血系数 = 1.8
		灵力系数 = 1.3
		速度系数 = 0.9
		法防系数 = 2.4
		防御系数 = 2.4
		难度等级 = 4
	elseif 任务数据[任务id].名称 == "履水吐焰地煞星" then
		伤害系数 = 1.5
		气血系数 = 2
		灵力系数 = 1.5
		速度系数 = 1.1
		法防系数 = 3
		防御系数 = 3
		难度等级 = 5
	end

	local 模型1 = {
		{
			"铁血",
			{
				"幽灵",
				"进阶天兵"
			}
		},
		{
			"铁血",
			{
				"律法女娲",
				"鬼将"
			}
		},
		{
			"铁血无双",
			{
				"蚩尤武魂",
				"噬天虎"
			}
		},
		{
			"铁血无双",
			{
				"进阶夜罗刹",
				"死亡骑士"
			}
		},
		{
			"铁血无双",
			{
				"进阶大力金刚",
				"龙虾骑士"
			}
		}
	}
	local 抗物 = {
		死亡骑士 = 1,
		混沌兽 = 1,
		鬼将 = 1,
		进阶大力金刚 = 1
	}
	local 抗法 = {
		进阶夜罗刹 = 1,
		龙鲤 = 1,
		画魂 = 1,
		灵鹤 = 1,
		噬天虎 = 1
	}
	local 双抗 = {
		炎魔神 = 1,
		律法女娲 = 1,
		龙虾骑士 = 1
	}
	local 模型2 = {
		{
			"玄法",
			{
				"炎魔神",
				"泪妖"
			}
		},
		{
			"玄法",
			{
				"灵符女娲",
				"画魂"
			}
		},
		{
			"玄法无边",
			{
				"灵鹤",
				"涂山瞳"
			}
		},
		{
			"玄法无边",
			{
				"混沌兽",
				"月影兔"
			}
		},
		{
			"玄法无边",
			{
				"龙鲤",
				"月影仙"
			}
		}
	}
	local 模型3 = {
		{
			"神封",
			{
				"雾中仙",
				"星灵仙子"
			}
		},
		{
			"神封",
			{
				"鼠先锋",
				"雾中仙"
			}
		},
		{
			"神封无量",
			{
				"兔子怪",
				"鼠先锋"
			}
		},
		{
			"神封无量",
			{
				"火女",
				"灵灯侍者"
			}
		},
		{
			"神封无量",
			{
				"鼠先锋",
				"雾中仙"
			}
		}
	}
	local 模型4 = {
		{
			"长生",
			{
				"龟丞相",
				"凤凰"
			}
		},
		{
			"长生",
			{
				"锦毛貂精",
				"巡游天神"
			}
		},
		{
			"长生无界",
			{
				"龙龟",
				"玄武"
			}
		},
		{
			"长生无界",
			{
				"龙龟",
				"玄武"
			}
		},
		{
			"长生无界",
			{
				"龙龟",
				"玄武"
			}
		}
	}
	local 模型5 = {
		{
			"乾坤",
			{
				"吸血鬼"
			}
		},
		{
			"乾坤",
			{
				"吸血鬼"
			}
		},
		{
			"乾坤无行",
			{
				"吸血鬼"
			}
		},
		{
			"乾坤无行",
			{
				"吸血鬼"
			}
		},
		{
			"乾坤无行",
			{
				"吸血鬼"
			}
		}
	}
	local 地煞门派 = 取地煞门派(任务数据[任务id].模型)
	战斗单位[1] = {
		角色 = true,
		不可封印 = true,
		愤怒 = 99999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
		门派 = 地煞门派,
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1.3,
		气血 = 气血系数 * 阶段属性[等级].气血 * 2 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1.3,
		速度 = 速度系数 * 阶段属性[等级].速度 * 1.5,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.35,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.55,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		等级 = 等级,
		技能 = {},
		主动技能 = 取门派主动法术(地煞门派)
	}
	local n = 2
	local 被动 = {}
	local 主动 = {}
	local 怪物名称 = ""
	被动 = {
		"高级必杀"
	}
	主动 = {
		"横扫千军",
		"天雷斩",
		"飘渺式"
	}

	if 难度等级 > 2 then
		主动 = 列表2加入到列表1(主动, {
			"烟雨剑法"
		})
	end

	战斗单位[n] = {
		愤怒 = 99999,
		名称 = 模型1[难度等级][1],
		模型 = 模型1[难度等级][2][取随机数(1, #模型1[难度等级][2])],
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
		气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
		速度 = 速度系数 * 阶段属性[等级].速度 * 1.3,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.3,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		等级 = 等级,
		技能 = 被动,
		主动技能 = 主动 or {}
	}

	if 难度等级 > 1 then
		n = n + 1
		主动 = {
			"变身",
			"鹰击",
			"飘渺式"
		}

		if 难度等级 > 2 then
			主动 = 列表2加入到列表1(主动, {
				"烟雨剑法",
				"天雷斩"
			})
		end

		if 难度等级 > 4 then
			主动 = 列表2加入到列表1(主动, {
				"连环击"
			})
		end

		战斗单位[n] = {
			愤怒 = 99999,
			名称 = 模型1[难度等级][1],
			模型 = 模型1[难度等级][2][取随机数(1, #模型1[难度等级][2])],
			伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
			气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
			灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
			速度 = 速度系数 * 阶段属性[等级].速度 * 1.3,
			防御 = 防御系数 * 阶段属性[等级].防御 * 0.3,
			法防 = 法防系数 * 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼,
			等级 = 等级,
			技能 = 被动,
			主动技能 = 主动 or {}
		}
	end

	n = n + 1
	被动 = {
		"高级法术连击",
		"高级法术暴击",
		"高级法术波动",
		"高级魔之心"
	}
	主动 = {
		"三昧真火",
		"龙卷雨击",
		"飞砂走石"
	}

	if 难度等级 > 2 then
		主动 = 列表2加入到列表1(主动, {
			"二龙戏珠"
		})
	end

	战斗单位[n] = {
		愤怒 = 99999,
		名称 = 模型2[难度等级][1],
		模型 = 模型2[难度等级][2][取随机数(1, #模型2[难度等级][2])],
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
		气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1.3,
		速度 = 速度系数 * 阶段属性[等级].速度 * 0.8,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.2,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = 被动,
		主动技能 = 主动 or {}
	}

	if 难度等级 > 1 then
		n = n + 1
		被动 = {
			"高级法术连击",
			"高级法术暴击",
			"高级法术波动",
			"高级鬼魂术"
		}
		主动 = {
			"龙腾",
			"夺命咒",
			"巨岩破"
		}

		if 难度等级 > 2 then
			主动 = 列表2加入到列表1(主动, {
				"天降灵葫"
			})
		end

		战斗单位[n] = {
			愤怒 = 99999,
			名称 = 模型2[难度等级][1] .. "·鬼",
			模型 = 模型2[难度等级][2][取随机数(1, #模型2[难度等级][2])],
			伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
			气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
			灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1.3,
			速度 = 速度系数 * 阶段属性[等级].速度 * 0.8,
			防御 = 防御系数 * 阶段属性[等级].防御 * 0.2,
			法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = 被动,
			主动技能 = 主动 or {}
		}
	end

	if 难度等级 > 2 then
		n = n + 1
		local 可变类型 = 取门派类型(地煞门派)

		if 可变类型 == "法术" then
			怪物名称 = 模型2[难度等级][1]
			被动 = {
				"高级法术连击",
				"高级敏捷",
				"高级法术暴击"
			}
			主动 = {
				"龙卷雨击",
				"落叶萧萧",
				"飞砂走石"
			}

			if 难度等级 > 2 then
				主动 = {
					"落叶萧萧"
				}
			end
		elseif 可变类型 == "物理" then
			怪物名称 = 模型1[难度等级][1]
			被动 = {
				"高级必杀"
			}
			主动 = {
				"变身",
				"鹰击",
				"天雷斩",
				"飘渺式"
			}
		elseif 可变类型 == "封印" then
			怪物名称 = 模型3[难度等级][1]
			被动 = {
				"高级敏捷",
				"高级反震",
				"高级连击",
				"高级强力"
			}
			主动 = {
				"失心符",
				"定身符",
				"反间之计"
			}
		elseif 可变类型 == "辅助" then
			怪物名称 = 模型4[难度等级][1]
			被动 = {
				"高级再生",
				"高级强壮",
				"高级防御",
				"高级法术暴击"
			}
			主动 = {
				"推气过宫",
				"起死回生"
			}

			if 难度等级 > 3 then
				主动 = 列表2加入到列表1(主动, {
					"命疗术"
				})
			end
		end

		战斗单位[n] = {
			愤怒 = 99999,
			名称 = 怪物名称,
			模型 = 模型2[难度等级][2][取随机数(1, #模型2[难度等级][2])],
			伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
			气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
			灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
			速度 = 速度系数 * 阶段属性[等级].速度 * 1,
			防御 = 防御系数 * 阶段属性[等级].防御 * 0.3,
			法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼,
			等级 = 等级,
			技能 = 被动,
			主动技能 = 主动 or {}
		}

		if 可变类型 == "封印" then
			战斗单位[n].速度 = 战斗单位[n].速度 * 2
		end
	end

	n = n + 1
	被动 = {
		"敏捷",
		"高级鬼魂术",
		"高级连击",
		"高级强力"
	}
	怪物名称 = 模型3[难度等级][1] .. "·鬼"
	主动 = {
		"含情脉脉",
		"夺魄令",
		"煞气诀"
	}

	if 难度等级 > 1 then
		怪物名称 = 模型3[难度等级][1]
		被动 = {
			"高级敏捷",
			"神佑复生",
			"高级连击",
			"高级强力"
		}
	end

	if 难度等级 > 2 then
		主动 = 列表2加入到列表1(主动, {
			"莲步轻舞"
		})
	end

	战斗单位[n] = {
		愤怒 = 99999,
		名称 = 怪物名称,
		模型 = 模型3[难度等级][2][取随机数(1, #模型3[难度等级][2])],
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
		气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
		速度 = 速度系数 * 阶段属性[等级].速度 * 2,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.3,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		等级 = 等级,
		技能 = 被动,
		主动技能 = 主动 or {}
	}
	n = n + 1
	主动 = {
		"失心符",
		"似玉生香",
		"日月乾坤"
	}
	战斗单位[n] = {
		愤怒 = 99999,
		名称 = 怪物名称,
		模型 = 模型3[难度等级][2][取随机数(1, #模型3[难度等级][2])],
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
		气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
		速度 = 速度系数 * 阶段属性[等级].速度 * 2,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.3,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		等级 = 等级,
		技能 = 被动,
		主动技能 = 主动 or {}
	}
	n = n + 1
	被动 = {
		"高级再生",
		"高级鬼魂术",
		"高级连击",
		"高级防御"
	}
	怪物名称 = 模型4[难度等级][1] .. "·鬼"
	主动 = {
		"金刚护体",
		"金刚护法",
		"普渡众生"
	}

	if 难度等级 > 1 then
		怪物名称 = 模型4[难度等级][1]
		被动 = {
			"高级再生",
			"高级强壮",
			"高级防御",
			"高级法术暴击"
		}
	end

	if 难度等级 > 2 then
		主动 = 列表2加入到列表1(主动, {
			"明光宝烛",
			"四海升平"
		})
	end

	if 难度等级 > 3 then
		主动 = 列表2加入到列表1(主动, {
			"晶清诀",
			"罗汉金钟"
		})
	end

	战斗单位[n] = {
		愤怒 = 99999,
		名称 = 怪物名称,
		模型 = 模型4[难度等级][2][取随机数(1, #模型4[难度等级][2])],
		伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1,
		气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
		灵力 = 灵力系数 * 阶段属性[等级].法伤 * 2,
		速度 = 速度系数 * 阶段属性[等级].速度 * 1.4,
		防御 = 防御系数 * 阶段属性[等级].防御 * 0.4,
		法防 = 法防系数 * 阶段属性[等级].法防 * 0.6,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 99,
		攻击修炼 = 阶段属性[等级].修炼 / 2,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼 / 2,
		抗法修炼 = 阶段属性[等级].修炼,
		等级 = 等级,
		技能 = 被动,
		主动技能 = 主动 or {}
	}

	if 难度等级 > 2 then
		n = n + 1
		被动 = {
			"高级隐身",
			"高级感知",
			"高级必杀",
			"高级连击"
		}
		主动 = {
			"善恶有报",
			"力劈华山",
			"烟雨剑法",
			"天雷斩",
			"飘渺式"
		}
		战斗单位[n] = {
			愤怒 = 99999,
			名称 = 模型5[难度等级][1],
			模型 = 模型5[难度等级][2][取随机数(1, #模型5[难度等级][2])],
			伤害 = 伤害系数 * 阶段属性[等级].伤害 * 1.3,
			气血 = 气血系数 * 阶段属性[等级].气血 * 1 + 5000,
			灵力 = 灵力系数 * 阶段属性[等级].法伤 * 1,
			速度 = 速度系数 * 阶段属性[等级].速度 * 0.7,
			防御 = 防御系数 * 阶段属性[等级].防御 * 0.35,
			法防 = 法防系数 * 阶段属性[等级].法防 * 0.4,
			躲避 = 阶段属性[等级].躲避,
			魔法 = 阶段属性[等级].魔法 * 99,
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼,
			等级 = 等级,
			技能 = 被动,
			主动技能 = 主动 or {}
		}
	end

	战斗单位[1].召唤减少 = 0.8

	for i = 2, #战斗单位 do
		战斗单位[i].召唤减少 = 0.8

		if 抗物[战斗单位[i].模型] ~= nil then
			战斗单位[i].物伤减少 = 0.5
		elseif 抗法[战斗单位[i].模型] ~= nil then
			战斗单位[i].法伤减少 = 0.5
		elseif 双抗[战斗单位[i].模型] ~= nil then
			战斗单位[i].法伤减少 = 0.6
			战斗单位[i].物伤减少 = 0.6
			战斗单位[i].气血 = qz(战斗单位[i].气血 * 0.8)
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取天罡星信息(任务id, 玩家id)
	local 战斗单位 = {
		阵法 = 阵法名称[取随机数(2, #阵法名称)]
	}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		愤怒 = 99999,
		法伤减少 = 0.9,
		角色 = true,
		不可封印 = true,
		物伤减少 = 0.9,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
		气血 = 阶段属性[等级].气血 * 4,
		魔法 = 阶段属性[等级].魔法 * 50,
		伤害 = 阶段属性[等级].伤害 * 2,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 1.3,
		防御 = 阶段属性[等级].防御 * 0.9,
		法防 = 阶段属性[等级].法防 * 1.3,
		躲避 = 阶段属性[等级].躲避 * 1,
		等级 = 等级,
		技能 = {
			"高级神佑复生"
		},
		主动技能 = Q_门派法术[门派名称[ygsj(#门派名称)]],
		攻击修炼 = 阶段属性[等级].修炼,
		防御修炼 = 阶段属性[等级].修炼,
		法术修炼 = 阶段属性[等级].修炼,
		抗法修炼 = 阶段属性[等级].修炼
	}

	for i = 2, 3 do
		local 造型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(造型)
		战斗单位[i] = {
			愤怒 = 9999,
			角色 = true,
			名称 = Q_天罡星名称[取随机数(1, #Q_天罡星名称)],
			模型 = 造型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			气血 = 阶段属性[等级].气血 * 2.5,
			魔法 = 阶段属性[等级].魔法 * 30,
			伤害 = 阶段属性[等级].伤害 * 1.5,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.9,
			防御 = 阶段属性[等级].防御 * 0.75,
			法防 = 阶段属性[等级].法防 * 0.7,
			躲避 = 阶段属性[等级].躲避 * 1,
			等级 = 等级,
			技能 = {
				"高级神佑复生"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"壁垒击破",
				"剑荡四方",
				"天雷斩",
				"破血狂攻",
				"破碎无双"
			},
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼
		}
	end

	for i = 4, 5 do
		local 造型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(造型)
		战斗单位[i] = {
			愤怒 = 9999,
			角色 = true,
			名称 = Q_天罡星名称[取随机数(1, #Q_天罡星名称)],
			模型 = 造型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			气血 = 阶段属性[等级].气血 * 2.5,
			魔法 = 阶段属性[等级].魔法 * 30,
			伤害 = 阶段属性[等级].伤害 * 1,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 0.8,
			防御 = 阶段属性[等级].防御 * 0.6,
			法防 = 阶段属性[等级].法防 * 1,
			躲避 = 阶段属性[等级].躲避 * 1,
			等级 = 等级,
			技能 = {
				"高级神佑复生"
			},
			主动技能 = {
				"落叶萧萧",
				"三昧真火",
				"飞砂走石",
				"八凶法阵",
				"上古灵符",
				"龙卷雨击",
				"龙吟"
			},
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼
		}
	end

	for i = 6, 7 do
		local 造型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(造型)
		战斗单位[i] = {
			愤怒 = 9999,
			角色 = true,
			名称 = Q_天罡星名称[取随机数(1, #Q_天罡星名称)],
			模型 = 造型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			气血 = 阶段属性[等级].气血 * 2.5,
			魔法 = 阶段属性[等级].魔法 * 30,
			伤害 = 阶段属性[等级].伤害 * 1,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 2,
			防御 = 阶段属性[等级].防御 * 0.75,
			法防 = 阶段属性[等级].法防 * 1,
			躲避 = 阶段属性[等级].躲避 * 1,
			等级 = 等级,
			技能 = {
				"高级神佑复生"
			},
			主动技能 = 夜光随机封印法术(5),
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼
		}
	end

	for i = 8, 9 do
		local 造型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(造型)
		战斗单位[i] = {
			愤怒 = 9999,
			角色 = true,
			名称 = Q_天罡星名称[取随机数(1, #Q_天罡星名称)],
			模型 = 造型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			气血 = 阶段属性[等级].气血 * 3.5,
			魔法 = 阶段属性[等级].魔法 * 30,
			伤害 = 阶段属性[等级].伤害 * 0.5,
			灵力 = 阶段属性[等级].法伤 * 1.5 * 2,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.8,
			法防 = 阶段属性[等级].法防 * 1,
			躲避 = 阶段属性[等级].躲避 * 1,
			等级 = 等级,
			技能 = {
				"高级神佑复生"
			},
			主动技能 = 列表2加入到列表1({
				"金刚护法",
				"韦陀护法",
				"四海升平",
				"晶清诀",
				"罗汉金钟"
			}, 夜光随机恢复法术(3)),
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼
		}
	end

	for i = 10, 10 do
		local 造型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(造型)
		战斗单位[i] = {
			愤怒 = 9999,
			角色 = true,
			名称 = Q_天罡星名称[取随机数(1, #Q_天罡星名称)],
			模型 = 造型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			气血 = 阶段属性[等级].气血 * 3,
			魔法 = 阶段属性[等级].魔法 * 30,
			伤害 = 阶段属性[等级].伤害 * 1.5,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.75,
			法防 = 阶段属性[等级].法防 * 1,
			躲避 = 阶段属性[等级].躲避 * 1,
			等级 = 等级,
			技能 = {
				"高级神佑复生"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"壁垒击破",
				"剑荡四方",
				"天雷斩",
				"破血狂攻",
				"破碎无双"
			},
			攻击修炼 = 阶段属性[等级].修炼 / 2,
			防御修炼 = 阶段属性[等级].修炼,
			法术修炼 = 阶段属性[等级].修炼 / 2,
			抗法修炼 = 阶段属性[等级].修炼
		}
	end

	return 全局战斗难度调整(战斗单位, 0.95)
end

function 战斗准备类:取知了王信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = math.min(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5, 取队伍最高等级数(玩家数据[玩家id].队伍, 玩家id))
	local 随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	战斗单位.阵法 = 随机阵法[取随机数(1, #随机阵法)]
	local 修炼最大值 = 10
	战斗单位[1] = {
		愤怒 = 9999,
		法伤减少 = 0.9,
		物伤减少 = 0.9,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 18 + 700,
		气血 = 等级 * 400,
		灵力 = 等级 * 18,
		速度 = 等级 * 10,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 6,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级幸运",
			"高级偷袭",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"飞砂走石",
			"龙卷雨击",
			"破碎无双"
		}
	}
	修炼最大值 = 8
	战斗单位[2] = {
		变异 = true,
		模型 = "幽灵",
		名称 = "诡秘千疑",
		伤害 = 等级 * 15 + 700,
		气血 = 等级 * 100,
		灵力 = 等级 * 10,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 5,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级必杀",
			"高级幸运",
			"高级偷袭"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[3] = {
		变异 = true,
		模型 = "进阶幽灵",
		名称 = "诡秘千疑",
		伤害 = 等级 * 15 + 700,
		气血 = 等级 * 100,
		灵力 = 等级 * 8,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级必杀",
			"高级幸运",
			"高级偷袭"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[4] = {
		模型 = "幽灵",
		名称 = "诡秘千疑",
		伤害 = 等级 * 10,
		气血 = 等级 * 100,
		灵力 = 等级 * 16,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"神佑复生",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = Q_门派法术.魔王寨
	}
	战斗单位[5] = {
		模型 = "进阶幽灵",
		名称 = "诡秘千疑",
		伤害 = 等级 * 10,
		气血 = 等级 * 100,
		灵力 = 等级 * 16,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"神佑复生",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = Q_门派法术.龙宫
	}
	战斗单位[6] = {
		模型 = "野猪精",
		名称 = "喽罗",
		伤害 = 等级 * 16 + 800,
		气血 = 等级 * 100,
		灵力 = 等级 * 16,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"鬼魂术"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[7] = {
		模型 = "野猪精",
		名称 = "喽罗",
		伤害 = 等级 * 12 + 800,
		气血 = 等级 * 100,
		灵力 = 等级 * 16,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"鬼魂术"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[8] = {
		模型 = "琴仙",
		名称 = "神封无量",
		伤害 = 等级 * 12 + 800,
		气血 = 等级 * 200,
		灵力 = 等级 * 20,
		速度 = 等级 * 11,
		防御 = 等级 * 10,
		法防 = 等级 * 30,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级再生"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"似玉生香",
			"反间之计"
		}
	}
	战斗单位[9] = {
		愤怒 = 99999999,
		模型 = "进阶龙龟",
		名称 = "长生不死",
		伤害 = 等级 * 16 + 800,
		气血 = 等级 * 200,
		灵力 = 等级 * 20,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 100,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级防御"
		},
		主动技能 = {
			"金刚护体",
			"金刚护法",
			"普度众生"
		}
	}
	战斗单位[10] = {
		愤怒 = 99999999,
		不可封印 = true,
		模型 = "进阶龙龟",
		名称 = "长生不老",
		伤害 = 等级 * 16 + 800,
		气血 = 等级 * 200,
		灵力 = 等级 * 20,
		速度 = 等级 * 5,
		防御 = 等级 * 15,
		法防 = 等级,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 100,
		等级 = 等级,
		攻击修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		防御修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		法术修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		抗法修炼 = math.floor(math.min(取人物修炼等级上限1(等级), 修炼最大值)),
		技能 = {
			"高级防御",
			"高级神迹"
		},
		主动技能 = {
			"推气过宫",
			"罗汉金钟",
			"圣灵之甲"
		}
	}

	return 全局战斗难度调整(战斗单位, 0.95)
end

function 战斗准备类:取妖王鬼将(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 20,
		气血 = 等级 * 等级 * 3,
		灵力 = 等级 * 8,
		速度 = 等级 * 10,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 8,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[2] = {
		魔法 = 99999900,
		模型 = "吸血鬼",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[3] = {
		魔法 = 99999900,
		模型 = "幽灵",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[4] = {
		魔法 = 99999900,
		模型 = "吸血鬼",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[5] = {
		魔法 = 99999900,
		模型 = "幽灵",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[6] = {
		魔法 = 99999900,
		模型 = "吸血鬼",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[7] = {
		魔法 = 99999900,
		模型 = "幽灵",
		名称 = "幽冥鬼卒",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(11, 15)]]
	}
	战斗单位[8] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "花妖",
		名称 = "狸",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 5,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"含情脉脉"
		}
	}

	return 全局战斗难度调整(战斗单位, 0.95)
end

function 战斗准备类:取妖王炎魔神(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 20,
		气血 = 等级 * 等级 * 3,
		灵力 = 等级 * 8,
		速度 = 等级 * 4,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 8,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级反震",
			"高级反击"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[2] = {
		魔法 = 99999900,
		模型 = "黑山老妖",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[3] = {
		魔法 = 99999900,
		模型 = "地狱战神",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[4] = {
		魔法 = 99999900,
		模型 = "黑山老妖",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[5] = {
		魔法 = 99999900,
		模型 = "地狱战神",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[6] = {
		魔法 = 99999900,
		模型 = "黑山老妖",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[7] = {
		魔法 = 99999900,
		模型 = "地狱战神",
		名称 = "上古魔灵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(1, 5)]]
	}
	战斗单位[8] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "狐狸精",
		名称 = "狐",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"似玉生香",
			"反间之计"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取妖王净瓶女娲(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 20,
		气血 = 等级 * 等级 * 3,
		灵力 = 等级 * 8,
		速度 = 等级 * 4,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 8,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[2] = {
		魔法 = 99999900,
		模型 = "灵符女娲",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[3] = {
		魔法 = 99999900,
		模型 = "噬天虎",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[4] = {
		魔法 = 99999900,
		模型 = "灵符女娲",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[5] = {
		魔法 = 99999900,
		模型 = "灵符女娲",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[6] = {
		魔法 = 99999900,
		模型 = "灵符女娲",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[7] = {
		魔法 = 99999900,
		模型 = "灵符女娲",
		名称 = "九天妖兵",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术[Q_门派编号[取随机数(6, 10)]]
	}
	战斗单位[8] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "花妖",
		名称 = "狸",
		伤害 = 等级 * 14,
		气血 = 等级 * 等级 * 1.5,
		灵力 = 等级 * 6,
		速度 = 等级 * 3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"日月乾坤",
			"反间之计"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取星宿任务信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz1(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) / 10 + 1) * 10
	local zd, bd = nil

	if ygsj() > 50 then
		bd = {
			"高级感知",
			"高级夜战",
			"神佑复生",
			"高级必杀",
			"高级蛮劲",
			"高级物理穿透",
			"高级报复"
		}
		zd = Q_门派法术[物理门派[ygsj(#物理门派)]]
	else
		bd = {
			"高级感知",
			"高级夜战",
			"神佑复生",
			"高级法术连击",
			"高级魔之心",
			"高级法术穿透",
			"高级报复"
		}
		zd = Q_门派法术[法术门派[ygsj(#法术门派)]]
	end

	战斗单位[1] = {
		愤怒 = 9999,
		不可封印 = true,
		模型 = "天兵",
		名称 = 任务数据[任务id].名称,
		伤害 = 阶段属性[等级].伤害 * 2.5,
		气血 = 阶段属性[等级].气血 * 10 + 30000,
		灵力 = 阶段属性[等级].法伤 * 2.5,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.35,
		法防 = 阶段属性[等级].法防 * 0.35,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 100,
		等级 = 等级,
		攻击修炼 = math.max(qz1(阶段属性[等级].修炼), 10),
		防御修炼 = math.max(qz1(阶段属性[等级].修炼), 10),
		法术修炼 = math.max(qz1(阶段属性[等级].修炼), 10),
		抗法修炼 = math.max(qz1(阶段属性[等级].修炼), 10),
		技能 = bd,
		主动技能 = zd
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取科举闯关信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级 + 5

	for n = 1, 5 do
		战斗单位[n] = {
			魔法 = 99999900,
			模型 = "护卫",
			名称 = "护卫",
			伤害 = 等级 * 6,
			气血 = 等级 * 30,
			灵力 = 等级 * 4.5,
			速度 = 等级 * 3,
			防御 = 等级 * 3,
			法防 = 等级 * 3.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取宝图遇怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz(玩家数据[玩家id].角色.数据.等级 / 10) * 10
	战斗单位[1] = {
		模型 = "黑山老妖",
		名称 = "远古魔王",
		伤害 = 阶段属性[等级].伤害 * 1,
		气血 = 阶段属性[等级].气血 * 0.8,
		灵力 = 阶段属性[等级].法伤 * 1,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {}
	}

	if 取随机数() <= 50 then
		战斗单位[1].模型 = "地狱战神"
	end

	local 临时信息 = 取等级怪(取随机数(1, 80))
	local 临时模型 = 取敌人信息(临时信息[取随机数(1, #临时信息)])
	战斗单位[2] = {
		名称 = "喽罗",
		模型 = 临时模型[2],
		伤害 = 阶段属性[等级].伤害 * 0.8,
		气血 = 阶段属性[等级].气血 * 0.5,
		灵力 = 阶段属性[等级].法伤 * 0.8,
		速度 = 阶段属性[等级].速度 * 1,
		防御 = 阶段属性[等级].防御 * 0.3,
		法防 = 阶段属性[等级].法防 * 0.3,
		躲避 = 阶段属性[等级].躲避,
		魔法 = 阶段属性[等级].魔法 * 2,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:显示(x, y)
end

function 战斗准备类:天庭叛逆(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]
	战斗单位[1] = {
		法伤减少 = 0.9,
		愤怒 = 9999,
		物伤减少 = 0.9,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		气血 = 阶段属性[等级].气血 * 1.1,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 1.1,
		灵力 = 阶段属性[等级].法伤 * 1.2,
		速度 = 阶段属性[等级].速度 * 1.55,
		防御 = 阶段属性[等级].防御 * 0.2,
		法防 = 阶段属性[等级].法防 * 0.2,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		等级 = 等级,
		技能 = {
			"高级感知",
			"高级必杀",
			"高级魔之心",
			"高级法术连击",
			"高级连击"
		},
		主动技能 = 技能范围[取随机数(1, #技能范围)]
	}
	local 模型范围 = {
		"持国巡守",
		"毗舍童子",
		"灵灯侍者",
		"般若天女",
		"真陀护法",
		"增长巡守",
		"金身罗汉",
		"曼珠沙华",
		"红萼仙子",
		"琴仙",
		"金铙僧",
		"灵鹤",
		"雾中仙",
		"大力金刚",
		"净瓶女娲",
		"律法女娲",
		"灵符女娲",
		"如意仙子",
		"巡游天神",
		"星灵仙子",
		"蛟龙",
		"凤凰",
		"雨师",
		"天兵",
		"风伯",
		"龟丞相",
		"小龙女"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]

	for i = 2, 7 + ygsj(3) do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			愤怒 = 9999,
			名称 = "叛逆的" .. 模型,
			模型 = 模型,
			气血 = 阶段属性[等级].气血 * 0.8,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.9,
			灵力 = 阶段属性[等级].法伤 * 1,
			速度 = 阶段属性[等级].速度 * 0.7,
			防御 = 阶段属性[等级].防御 * 0.15,
			法防 = 阶段属性[等级].法防 * 0.15,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击",
				"必杀",
				"连击"
			},
			主动技能 = 取随机法术(3)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

取平均阶段等级 = function(玩家id)
	if 玩家数据[玩家id].队伍 == nil then
		return qz1(玩家数据[玩家id].角色.数据.等级 / 10) * 10
	end

	return qz1(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) / 10) * 10
end

function 战斗准备类:捣乱的水果(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = qz1((任务数据[任务id].等级 + 5) / 10) * 10
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位.阵法 = 取随机阵法()
	战斗单位[1] = {
		愤怒 = 9999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		气血 = 阶段属性[等级].气血 * 1.1,
		魔法 = 阶段属性[等级].魔法 * 10,
		伤害 = 阶段属性[等级].伤害 * 1,
		灵力 = 阶段属性[等级].法伤 * 1.1,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.15,
		法防 = 阶段属性[等级].法防 * 0.15,
		躲避 = 阶段属性[等级].躲避 * 0.5,
		等级 = 等级,
		技能 = 列表2加入到列表1({
			"魔之心",
			"高级法术连击"
		}, 取高级要诀(3)),
		主动技能 = Q_门派法术[门派名称[ygsj(#门派名称)]]
	}
	local 模型名称范围 = {
		"帮手",
		"小弟",
		"大哥",
		"女友",
		"兄弟",
		"舅舅",
		"叔叔",
		"同事",
		"共犯",
		"姐姐",
		"妹妹"
	}
	local 模型 = 模型库2[取随机数(1, #模型库2)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]
	local 人数 = 取队伍人数(玩家id)

	if 人数 == 1 then
		人数 = 3
	elseif 人数 == 5 then
		人数 = 取随机数(9, 10)
	elseif 人数 >= 3 then
		人数 = 取随机数(6, 8)
	else
		人数 = 取随机数(4, 6)
	end

	for i = 2, 人数 do
		模型 = 模型库2[取随机数(1, #模型库2)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			愤怒 = 9999,
			名称 = 模型 .. 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			气血 = 阶段属性[等级].气血 * 0.5,
			魔法 = 阶段属性[等级].魔法 * 10,
			伤害 = 阶段属性[等级].伤害 * 0.8,
			灵力 = 阶段属性[等级].法伤 * 0.9,
			速度 = 阶段属性[等级].速度 * 0.45,
			防御 = 阶段属性[等级].防御 * 0.05,
			法防 = 阶段属性[等级].法防 * 0.05,
			躲避 = 阶段属性[等级].躲避 * 0.5,
			等级 = 等级,
			技能 = 列表2加入到列表1({
				"夜战"
			}, 取低级要诀(3)),
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取大力神灵信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		显示饰品 = true,
		变异 = true,
		模型 = "天将",
		名称 = "大力神灵",
		伤害 = 阶段属性[等级].伤害 * 1.5,
		气血 = 阶段属性[等级].气血 * 5,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.35,
		法防 = 阶段属性[等级].法防 * 0.35,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = {
			"高级感知",
			"超级必杀",
			"高级物理穿透",
			"高级蛮劲",
			"超级偷袭",
			"昼伏夜出",
			"高级反击",
			"超级连击"
		},
		主动技能 = Q_门派法术.天宫
	}
	local 模型范围 = {
		"天兵"
	}
	local 模型名称范围 = {
		"天兵"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{},
		{},
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 1,
			气血 = 阶段属性[等级].气血 * 3,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].伤害,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = {
				"高级感知",
				"高级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"超级偷袭",
				"昼伏夜出",
				"高级反击",
				"高级连击",
				"高级法术暴击",
				"高级法术穿透",
				"高级魔之心",
				"高级魔法反击",
				"高级法术连击",
				"高级报复",
				"高级法术波动"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取妖魔亲信信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		法伤减少 = 1.3,
		变异 = true,
		显示饰品 = true,
		模型 = "蝴蝶仙子",
		名称 = "妖魔亲信",
		物伤减少 = 0.3,
		伤害 = 阶段属性[等级].伤害 * 2,
		气血 = 阶段属性[等级].气血 * 5,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 2,
		防御 = 阶段属性[等级].防御 * 0.35,
		法防 = 阶段属性[等级].法防 * 0.35,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = {
			"高级感知",
			"超级法术暴击",
			"高级法术穿透",
			"超级魔之心",
			"高级魔法反击",
			"超级法术连击",
			"高级报复",
			"超级法术波动"
		},
		主动技能 = 四系法术列表
	}
	local 技能范围 = {
		{},
		{},
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]
	local 模型范围 = {
		"蝴蝶仙子",
		"黑熊精",
		"黑山老妖",
		"蜘蛛精"
	}

	for i = 2, 7 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			物伤减少 = 0.5,
			显示饰品 = true,
			名称 = "妖魔喽罗",
			法伤减少 = 1.3,
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 3,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].伤害,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = {
				"高级感知",
				"高级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"超级偷袭",
				"昼伏夜出",
				"高级反击",
				"高级连击",
				"高级法术暴击",
				"高级法术穿透",
				"高级魔之心",
				"高级魔法反击",
				"高级法术连击",
				"高级报复",
				"高级法术波动"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取蜃妖元神信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		显示饰品 = true,
		变异 = true,
		模型 = "炎魔神",
		名称 = "蜃妖元神",
		伤害 = 阶段属性[等级].伤害 * 2.5,
		气血 = 阶段属性[等级].气血 * 8,
		灵力 = 阶段属性[等级].法伤 * 3,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.5,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = {
			"高级感知",
			"超级必杀",
			"高级物理穿透",
			"高级蛮劲",
			"超级偷袭",
			"昼伏夜出",
			"高级反击",
			"超级连击"
		},
		主动技能 = Q_门派法术.狮驼岭,
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			死地 = 1,
			翼展 = 1,
			宁息 = 1
		}
	}
	local 技能范围 = {
		{},
		{},
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]
	local 模型范围 = {
		"百足将军",
		"野猪精",
		"地狱战神"
	}

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			名称 = "小妖",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 2,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 1.5,
			防御 = 阶段属性[等级].防御 * 0.35,
			法防 = 阶段属性[等级].法防 * 0.35,
			躲避 = 阶段属性[等级].伤害,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = {
				"高级感知",
				"高级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"超级偷袭",
				"昼伏夜出",
				"高级反击",
				"高级连击",
				"高级法术暴击",
				"高级法术穿透",
				"高级魔之心",
				"高级魔法反击",
				"高级法术连击",
				"高级报复",
				"高级法术波动"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取周猎户信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		显示饰品 = true,
		变异 = true,
		模型 = "山贼",
		名称 = "周猎户",
		伤害 = 阶段属性[等级].伤害 * 3,
		气血 = 阶段属性[等级].气血 * 10,
		灵力 = 阶段属性[等级].法伤 * 3,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.5,
		法防 = 阶段属性[等级].法防 * 0.5,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = {
			"高级防御",
			"超级招架",
			"高级感知",
			"昼伏夜出",
			"超级必杀",
			"超级连击",
			"影袭",
			"烈焰斩",
			"高级蛮劲",
			"超级进击必杀",
			"理直气壮",
			"嗜血追击",
			"高级助攻",
			"高级反击",
			"高级魔法反击",
			"高级法术助攻"
		},
		主动技能 = {}
	}
	local 模型范围 = {
		"山贼",
		"强盗",
		"赌徒"
	}
	local 模型名称范围 = {
		"帮手"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{},
		{},
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			名称 = "帮手",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 2,
			气血 = 阶段属性[等级].气血 * 5,
			灵力 = 阶段属性[等级].法伤 * 2,
			速度 = 阶段属性[等级].速度 * 2,
			防御 = 阶段属性[等级].防御 * 0.35,
			法防 = 阶段属性[等级].法防 * 0.35,
			躲避 = 阶段属性[等级].伤害,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = {
				"高级防御",
				"高级招架",
				"高级感知",
				"超级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"高级偷袭",
				"昼伏夜出",
				"高级反击",
				"高级连击",
				"高级法术暴击",
				"高级法术穿透",
				"高级魔之心",
				"高级魔法反击",
				"高级法术连击",
				"高级报复",
				"高级法术波动"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取法宝战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取平均阶段等级(玩家id)
	战斗单位[1] = {
		显示饰品 = true,
		变异 = true,
		模型 = "山贼",
		名称 = 任务数据[任务id].人物,
		伤害 = 阶段属性[等级].伤害 * 2,
		气血 = 阶段属性[等级].气血 * 3,
		灵力 = 阶段属性[等级].法伤 * 2,
		速度 = 阶段属性[等级].速度 * 1.5,
		防御 = 阶段属性[等级].防御 * 0.35,
		法防 = 阶段属性[等级].法防 * 0.35,
		躲避 = 阶段属性[等级].伤害,
		魔法 = 阶段属性[等级].魔法 * 99,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型范围 = {
		"山贼",
		"强盗",
		"赌徒"
	}
	local 模型名称范围 = {
		"帮手"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			显示饰品 = true,
			名称 = "帮手",
			模型 = 模型,
			伤害 = 阶段属性[等级].伤害 * 1.5,
			气血 = 阶段属性[等级].气血 * 2,
			灵力 = 阶段属性[等级].法伤 * 1.5,
			速度 = 阶段属性[等级].速度 * 1,
			防御 = 阶段属性[等级].防御 * 0.3,
			法防 = 阶段属性[等级].法防 * 0.3,
			躲避 = 阶段属性[等级].伤害,
			魔法 = 阶段属性[等级].魔法 * 99,
			等级 = 等级,
			技能 = {
				"高级感知",
				"超级必杀",
				"高级物理穿透",
				"高级蛮劲",
				"超级偷袭",
				"昼伏夜出",
				"高级反击",
				"超级连击",
				"超级法术暴击",
				"高级法术穿透",
				"超级魔之心",
				"高级魔法反击",
				"超级法术连击",
				"高级报复",
				"超级法术波动"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取法宝内丹战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		显示饰品 = true,
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 13 + 500,
		气血 = 等级 * 400,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 5
	local 模型范围 = {
		"吸血鬼",
		"鬼将",
		"噬天虎",
		"灵鹤",
		"幽灵",
		"百足将军",
		"犀牛将军人形",
		"犀牛将军兽形"
	}
	local 模型名称范围 = {
		"帮手"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 13 + 500,
			气血 = 等级 * 200,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取横行霸道的土匪战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		显示饰品 = true,
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 13 + 500,
		气血 = 等级 * 300,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 5
	local 模型范围 = {
		"强盗",
		"山贼"
	}
	local 模型名称范围 = {
		"土匪喽罗"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 13 + 500,
			气血 = 等级 * 150,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升心魔战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		角色 = true,
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		染色方案 = 任务数据[任务id].染色方案,
		染色组 = 任务数据[任务id].染色组,
		武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
		武器染色方案 = 任务数据[任务id].武器染色方案,
		武器染色组 = 任务数据[任务id].武器染色组,
		伤害 = 等级 * 13 + 500,
		气血 = 等级 * 400,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 5
	local 模型范围 = {
		任务数据[任务id].模型
	}
	local 模型名称范围 = {
		任务数据[任务id].名称
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			角色 = true,
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			染色方案 = 任务数据[任务id].染色方案,
			染色组 = 任务数据[任务id].染色组,
			武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
			武器染色方案 = 任务数据[任务id].武器染色方案,
			武器染色组 = 任务数据[任务id].武器染色组,
			伤害 = 等级 * 13 + 500,
			气血 = 等级 * 200,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升小妖战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		魔法 = 99999900,
		模型 = "牛妖",
		名称 = "牛魔王小弟",
		伤害 = 等级 * 13 + 500,
		气血 = 等级 * 400,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 5
	local 模型范围 = {
		"牛妖"
	}
	local 模型名称范围 = {
		"牛魔王小弟"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 13 + 500,
			气血 = 等级 * 200,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升小宝箱战斗信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "鬼将",
		名称 = "不死壤守卫",
		伤害 = 等级 * 13 + 500,
		气血 = 等级 * 400,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 5
	local 模型范围 = {
		"鬼将",
		"吸血鬼",
		"幽灵",
		"画魂",
		"幽萤娃娃"
	}
	local 模型名称范围 = {
		"不死壤护卫"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 13 + 500,
			气血 = 等级 * 200,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升阵法1战斗信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {}
	local 等级 = 145

	print(阶段属性[等级].气血)

	战斗单位.阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性1(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 99999,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				气血 = 阶段属性[等级].气血 * 1,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.5,
				法防 = 阶段属性[等级].法防 * 0.5,
				躲避 = 阶段属性[等级].躲避 * 1.2,
				等级 = 等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(55, 175)[2]
			战斗单位[i] = {
				饰品 = true,
				名称 = "守护者的" .. 模型名称,
				模型 = "进阶" .. 模型名称,
				气血 = 阶段属性[等级].气血 * 0.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1,
				灵力 = 阶段属性[等级].法伤 * 1,
				速度 = 阶段属性[等级].速度 * 0.8,
				防御 = 阶段属性[等级].防御 * 0.5,
				法防 = 阶段属性[等级].法防 * 0.5,
				躲避 = 阶段属性[等级].躲避 * 1,
				等级 = 等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升阵法2战斗信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {}
	local 等级 = 150
	战斗单位.阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性1(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 99999,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				气血 = 阶段属性[等级].气血 * 1.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.15,
				灵力 = 阶段属性[等级].法伤 * 1.15,
				速度 = 阶段属性[等级].速度 * 1.15,
				防御 = 阶段属性[等级].防御 * 0.65,
				法防 = 阶段属性[等级].法防 * 0.65,
				躲避 = 阶段属性[等级].躲避 * 1.4,
				等级 = 等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(55, 175)[2]
			战斗单位[i] = {
				饰品 = true,
				名称 = "守护者的" .. 模型名称,
				模型 = "进阶" .. 模型名称,
				气血 = 阶段属性[等级].气血 * 1.3,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.15,
				灵力 = 阶段属性[等级].法伤 * 1.15,
				速度 = 阶段属性[等级].速度 * 1,
				防御 = 阶段属性[等级].防御 * 0.65,
				法防 = 阶段属性[等级].法防 * 0.65,
				躲避 = 阶段属性[等级].躲避 * 1.2,
				等级 = 等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升阵法3战斗信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {}
	local 等级 = 155
	战斗单位.阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性1(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 99999,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				气血 = 阶段属性[等级].气血 * 2,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.3,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.3,
				防御 = 阶段属性[等级].防御 * 0.8,
				法防 = 阶段属性[等级].法防 * 0.8,
				躲避 = 阶段属性[等级].躲避 * 1.6,
				等级 = 等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(55, 175)[2]
			战斗单位[i] = {
				饰品 = true,
				名称 = "守护者的" .. 模型名称,
				模型 = "进阶" .. 模型名称,
				气血 = 阶段属性[等级].气血 * 1.8,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.3,
				灵力 = 阶段属性[等级].法伤 * 1.3,
				速度 = 阶段属性[等级].速度 * 1.1,
				防御 = 阶段属性[等级].防御 * 0.8,
				法防 = 阶段属性[等级].法防 * 0.8,
				躲避 = 阶段属性[等级].躲避 * 1.4,
				等级 = 等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升阵法4战斗信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {
		阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]
	}
	local 等级 = 160

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性1(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 99999,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				气血 = 阶段属性[等级].气血 * 3,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.5,
				灵力 = 阶段属性[等级].法伤 * 1.5,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 1,
				法防 = 阶段属性[等级].法防 * 1,
				躲避 = 阶段属性[等级].躲避 * 1.8,
				等级 = 等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(55, 175)[2]
			战斗单位[i] = {
				饰品 = true,
				名称 = "守护者的" .. 模型名称,
				模型 = "进阶" .. 模型名称,
				气血 = 阶段属性[等级].气血 * 2.5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.5,
				灵力 = 阶段属性[等级].法伤 * 1.5,
				速度 = 阶段属性[等级].速度 * 1.3,
				防御 = 阶段属性[等级].防御 * 1,
				法防 = 阶段属性[等级].法防 * 1,
				躲避 = 阶段属性[等级].躲避 * 1.6,
				等级 = 等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取飞升阵法5战斗信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {}
	local 等级 = 165
	战斗单位.阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性1(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 99999,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				气血 = 阶段属性[等级].气血 * 5,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.75,
				灵力 = 阶段属性[等级].法伤 * 1.75,
				速度 = 阶段属性[等级].速度 * 1.7,
				防御 = 阶段属性[等级].防御 * 1.2,
				法防 = 阶段属性[等级].法防 * 1.2,
				躲避 = 阶段属性[等级].躲避 * 2,
				等级 = 等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(55, 175)[2]
			战斗单位[i] = {
				饰品 = true,
				名称 = "守护者的" .. 模型名称,
				模型 = "进阶" .. 模型名称,
				气血 = 阶段属性[等级].气血 * 4,
				魔法 = 阶段属性[等级].魔法 * 10,
				伤害 = 阶段属性[等级].伤害 * 1.75,
				灵力 = 阶段属性[等级].法伤 * 1.75,
				速度 = 阶段属性[等级].速度 * 1.5,
				防御 = 阶段属性[等级].防御 * 1.2,
				法防 = 阶段属性[等级].法防 * 1.2,
				躲避 = 阶段属性[等级].躲避 * 1.8,
				等级 = 等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 阶段属性[等级].修炼,
				防御修炼 = 阶段属性[等级].修炼,
				法术修炼 = 阶段属性[等级].修炼,
				抗法修炼 = 阶段属性[等级].修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 120
	战斗单位[1] = {
		愤怒 = 999,
		躲避 = 100,
		气血 = 150000,
		角色 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		不可封印 = true,
		伤害 = 4000,
		模型 = "剑侠客",
		名称 = "罗成",
		武器 = 取武器数据("霜冷九州", 150),
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			破空 = 1,
			念心 = 1,
			风刃 = 1,
			无敌 = 1,
			干将 = 1,
			勇念 = 1,
			杀意 = 1,
			破军 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"破釜沉舟",
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[2] = {
		愤怒 = 999,
		躲避 = 100,
		气血 = 150000,
		角色 = true,
		魔法 = 99999900,
		灵力 = 2500,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		不可封印 = true,
		伤害 = 3500,
		模型 = "巨魔王",
		名称 = "张副将",
		武器 = 取武器数据("碧血干戚", 150),
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	战斗单位[3] = {
		愤怒 = 999,
		躲避 = 100,
		气血 = 150000,
		角色 = true,
		魔法 = 99999900,
		灵力 = 2500,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		不可封印 = true,
		伤害 = 3500,
		模型 = "虎头怪",
		名称 = "李副将",
		武器 = 取武器数据("狂澜碎岳", 150),
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	战斗单位[4] = {
		躲避 = 5000,
		气血 = 300000,
		角色 = true,
		魔法 = 99999900,
		灵力 = 2000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		不可封印 = true,
		伤害 = 3000,
		模型 = "逍遥生",
		名称 = "护驾亲兵 ",
		武器 = 取武器数据("浩气长舒", 150),
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			诸天看护 = 1,
			舍利 = 1,
			心韧 = 1,
			佛屠 = 1,
			映法 = 1,
			仁心 = 1,
			佛誉 = 1,
			佛显 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"活血",
			"金刚护体",
			"金刚护法"
		}
	}
	战斗单位[5] = {
		躲避 = 5000,
		气血 = 300000,
		角色 = true,
		魔法 = 99999900,
		灵力 = 2000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		不可封印 = true,
		伤害 = 3000,
		模型 = "逍遥生",
		名称 = "护驾亲兵 ",
		武器 = 取武器数据("浩气长舒", 150),
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			诸天看护 = 1,
			舍利 = 1,
			心韧 = 1,
			佛屠 = 1,
			映法 = 1,
			仁心 = 1,
			佛誉 = 1,
			佛显 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"活血",
			"金刚护体",
			"金刚护法"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 300000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 3000,
			模型 = "护卫",
			名称 = "大唐骁勇",
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"破釜沉舟",
				"杀气诀"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 120
	战斗单位[1] = {
		气血 = 200000,
		不可封印 = false,
		魔法 = 99999900,
		灵力 = 3500,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "小魔头",
		名称 = "红孩儿",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
	}
	战斗单位[2] = {
		不可封印 = false,
		愤怒 = 999,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 100,
		伤害 = 4000,
		模型 = "牛妖",
		名称 = "护殿牛将",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	战斗单位[3] = {
		不可封印 = false,
		愤怒 = 999,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 100,
		伤害 = 4000,
		模型 = "牛妖",
		名称 = "护殿牛将",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	战斗单位[4] = {
		不可封印 = false,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 4000,
		模型 = "牛妖",
		名称 = "护殿牛将",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
	}
	战斗单位[5] = {
		不可封印 = false,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 4000,
		模型 = "牛妖",
		名称 = "护殿牛将",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 100000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 1500,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 3500,
			模型 = "炎魔神",
			名称 = "火云妖兵",
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			奇经八脉 = {
				烈焰真诀 = 1,
				返火 = 1,
				魔心 = 1,
				赤暖 = 1,
				震怒 = 1,
				神炎 = 1
			},
			技能 = {
				"高级反震",
				"高级感知",
				"高级驱鬼",
				"高级法术连击",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"火甲术",
				"摇头摆尾",
				"三昧真火",
				"飞砂走石",
				"牛劲"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 120
	战斗单位[1] = {
		不可封印 = true,
		气血 = 200000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "雨师",
		名称 = "雷祖",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "天兵",
		名称 = "邓天君",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "天兵",
		名称 = "辛天君",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "天兵",
		名称 = "张天君",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "天兵",
		名称 = "陶天君",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 100000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 2000,
			模型 = "天兵",
			名称 = "火云妖兵",
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			奇经八脉 = {
				傲翔 = 1,
				雷波 = 1,
				画地为牢 = 1,
				怒气 = 1,
				飞龙 = 1,
				威赫 = 1,
				神律 = 1
			},
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"天雷斩",
				"雷霆万钧",
				"龙卷雨击",
				"二龙戏珠",
				"神龙摆尾",
				"逆鳞"
			}
		}

		if n == 6 then
			战斗单位[n].名称 = "庞天君"
		elseif n == 7 then
			战斗单位[n].名称 = "刘天君"
		elseif n == 8 then
			战斗单位[n].名称 = "荀天君"
		elseif n == 9 then
			战斗单位[n].名称 = "毕天君"
		elseif n == 10 then
			战斗单位[n].名称 = "秦天君"
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息4(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 130
	战斗单位[1] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "雾中仙",
		名称 = "麻姑",
		等级 = 等级,
		奇经八脉 = {
			毒引 = 1,
			倩影 = 1,
			毒雾 = 1,
			嫣然 = 1,
			磐石 = 1,
			轻霜 = 1,
			杏花 = 1,
			暗伤 = 1,
			天香 = 1,
			鸿影 = 1,
			花舞 = 1,
			自矜 = 1,
			淬芒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级隐身",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"满天花雨",
			"雨落寒沙"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 200000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "律法女娲",
		名称 = "玫瑰护法",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 200000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "灵符女娲",
		名称 = "海棠护法",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "雾中仙",
		名称 = "荷花仙子",
		等级 = 等级,
		奇经八脉 = {
			毒引 = 1,
			倩影 = 1,
			毒雾 = 1,
			嫣然 = 1,
			磐石 = 1,
			轻霜 = 1,
			杏花 = 1,
			暗伤 = 1,
			天香 = 1,
			鸿影 = 1,
			花舞 = 1,
			自矜 = 1,
			淬芒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"满天花雨",
			"雨落寒沙"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "雾中仙",
		名称 = "梅花仙子",
		等级 = 等级,
		奇经八脉 = {
			毒引 = 1,
			倩影 = 1,
			毒雾 = 1,
			嫣然 = 1,
			磐石 = 1,
			轻霜 = 1,
			杏花 = 1,
			暗伤 = 1,
			天香 = 1,
			鸿影 = 1,
			花舞 = 1,
			自矜 = 1,
			淬芒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"满天花雨",
			"雨落寒沙"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 100000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 5000,
			模型 = "雾中仙",
			名称 = "火云妖兵",
			等级 = 等级,
			奇经八脉 = {
				毒引 = 1,
				倩影 = 1,
				毒雾 = 1,
				嫣然 = 1,
				磐石 = 1,
				轻霜 = 1,
				杏花 = 1,
				暗伤 = 1,
				天香 = 1,
				鸿影 = 1,
				花舞 = 1,
				自矜 = 1,
				淬芒 = 1
			},
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级反击",
				"高级夜战",
				"高级反震"
			},
			主动技能 = {
				"碎玉弄影",
				"飞符炼魂",
				"一笑倾城"
			}
		}

		if n == 6 then
			战斗单位[n].名称 = "桃花仙子"
		elseif n == 7 then
			战斗单位[n].名称 = "兰花仙子"
		elseif n == 8 then
			战斗单位[n].名称 = "梨花仙子"
		elseif n == 9 then
			战斗单位[n].名称 = "昙花仙子"
		elseif n == 10 then
			战斗单位[n].名称 = "菊花仙子"
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息5(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 130
	战斗单位[1] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "进阶如意仙子",
		名称 = "云霄仙子 ",
		等级 = 等级,
		奇经八脉 = {
			普渡 = 1,
			借灵 = 1,
			道衍 = 1,
			雨润 = 1,
			秘术 = 1,
			法咒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级隐身",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"普渡众生",
			"波澜不惊",
			"五行制化",
			"灵动九天"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "星灵仙子",
		名称 = "紫霞仙子",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 5000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 100,
		伤害 = 5000,
		模型 = "吸血鬼",
		名称 = "忘情护法",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			破空 = 1,
			念心 = 1,
			风刃 = 1,
			无敌 = 1,
			干将 = 1,
			勇念 = 1,
			杀意 = 1,
			破军 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"破釜沉舟",
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 5000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 100,
		伤害 = 5000,
		模型 = "吸血鬼",
		名称 = "忘情护法",
		等级 = 等级,
		奇经八脉 = {
			战诀 = 1,
			天神怒斩 = 1,
			暴气 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天崩地裂",
			"翻江搅海",
			"碎星诀",
			"浪涌"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 5000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 100,
		伤害 = 5000,
		模型 = "吸血鬼",
		名称 = "忘情护法",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 100000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 5000,
			模型 = "幽灵",
			名称 = "盘丝小仙",
			等级 = 等级,
			奇经八脉 = {
				脱壳 = 1,
				情劫 = 1,
				迷梦 = 1,
				鼓乐 = 1,
				结阵 = 1,
				粘附 = 1,
				媚态 = 1,
				迷意 = 1,
				妖气 = 1
			},
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级反击",
				"高级夜战",
				"高级反震"
			},
			主动技能 = {
				"含情脉脉",
				"瘴气",
				"魔音摄魂",
				"盘丝阵",
				"幻镜术",
				"天罗地网"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息6(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 130
	战斗单位[1] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "蛟龙",
		名称 = "龙王",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[2] = {
		气血 = 150000,
		不可封印 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "九头精怪",
		名称 = "九头驸马",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			烈焰真诀 = 1,
			返火 = 1,
			魔心 = 1,
			赤暖 = 1,
			震怒 = 1,
			神炎 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"火甲术",
			"摇头摆尾",
			"三昧真火",
			"飞砂走石",
			"牛劲"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "小龙女",
		名称 = "万圣公主",
		等级 = 等级,
		奇经八脉 = {
			普渡 = 1,
			借灵 = 1,
			道衍 = 1,
			雨润 = 1,
			秘术 = 1,
			法咒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"普渡众生",
			"波澜不惊",
			"五行制化",
			"灵动九天"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "净瓶女娲",
		名称 = "碧波水勇",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "净瓶女娲",
		名称 = "碧波水勇",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 100000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 10000,
			模型 = "净瓶女娲",
			名称 = "碧波水勇",
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			奇经八脉 = {
				法身 = 1,
				风灵 = 1,
				滋养 = 1
			},
			技能 = {
				"高级反震",
				"高级感知",
				"高级驱鬼",
				"高级法术连击",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"落叶萧萧",
				"蜜润",
				"风卷残云"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息7(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 140
	战斗单位[1] = {
		不可封印 = true,
		气血 = 500000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "雨师",
		名称 = "张天师",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			不倦 = 1,
			苦缠 = 1,
			化身 = 1,
			雷动 = 1,
			奔雷 = 1,
			鬼念 = 1,
			碎甲 = 1,
			批亢 = 1,
			鬼惧 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"碎甲符",
			"定身符",
			"失心符",
			"五雷咒",
			"落雷符",
			"分身术"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 200000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "雨师",
		名称 = "许天师",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "雨师",
		名称 = "萨天师",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 10000,
		模型 = "雨师",
		名称 = "许天师",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		气血 = 200000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1000,
		法防 = 1000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "天将",
		名称 = "司命星君",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 150000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 1000,
			速度 = 1000,
			防御 = 1000,
			法防 = 1000,
			躲避 = 5000,
			伤害 = 4000,
			模型 = "天将",
			名称 = "司命星君",
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			奇经八脉 = {
				不倦 = 1,
				苦缠 = 1,
				化身 = 1,
				雷动 = 1,
				奔雷 = 1,
				鬼念 = 1,
				碎甲 = 1,
				批亢 = 1,
				鬼惧 = 1
			},
			技能 = {
				"高级反震",
				"高级感知",
				"高级驱鬼",
				"高级法术连击",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"碎甲符",
				"定身符",
				"失心符",
				"五雷咒",
				"落雷符",
				"分身术"
			}
		}

		if n == 6 then
			战斗单位[n].名称 = "司禄星君"
		elseif n == 7 then
			战斗单位[n].名称 = "延寿星君"
		elseif n == 8 then
			战斗单位[n].名称 = "益算星君"
		elseif n == 9 then
			战斗单位[n].名称 = "度厄星君"
		elseif n == 10 then
			战斗单位[n].名称 = "上生星君"
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息8(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 140
	战斗单位[1] = {
		不可封印 = true,
		气血 = 500000,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "阎罗王",
		名称 = "转轮王",
		等级 = 等级,
		奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "野鬼",
		名称 = "平方王",
		等级 = 等级,
		奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "吸血鬼",
		名称 = "阴长生",
		等级 = 等级,
		奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "牛头",
		名称 = "牛头",
		等级 = 等级,
		奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "马面",
		名称 = "马面",
		等级 = 等级,
		奇经八脉 = {
			毒印 = 1,
			伤魂 = 1,
			击破 = 1,
			夜之王者 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"阎罗令",
			"判官令",
			"百爪狂杀",
			"六道无量",
			"尸腐毒"
		}
	}

	for n = 6, 10 do
		战斗单位[n] = {
			气血 = 200000,
			变异 = true,
			魔法 = 99999900,
			灵力 = 2000,
			速度 = 1000,
			防御 = 1500,
			法防 = 1500,
			躲避 = 1000,
			伤害 = 5000,
			模型 = "幽灵",
			名称 = "勾魂使者 ",
			等级 = 等级,
			奇经八脉 = {
				化莲 = 1,
				金莲 = 1,
				自愈 = 1,
				精进 = 1,
				反先 = 1,
				同舟共济 = 1,
				灵身 = 1
			},
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级法术暴击",
				"高级反击",
				"高级夜战"
			},
			主动技能 = {
				"地涌金莲",
				"夺命咒",
				"金身舍利",
				"摧心术",
				"明光宝烛",
				"同舟共济"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取生死劫信息9(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 150
	战斗单位[1] = {
		气血 = 500000,
		不可封印 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 2000,
		法防 = 2000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "九头精怪",
		名称 = "孔雀明王",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			怒气 = 1,
			雷波 = 1,
			画地为牢 = 1,
			威赫 = 1,
			神律 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"天雷斩",
			"雷霆万钧"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 500000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "大力金刚",
		名称 = "泼法金刚 ",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			诸天看护 = 1,
			舍利 = 1,
			心韧 = 1,
			佛屠 = 1,
			映法 = 1,
			仁心 = 1,
			佛誉 = 1,
			佛显 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"活血"
		}
	}
	战斗单位[3] = {
		不可封印 = true,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "大力金刚",
		名称 = "胜至金刚",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			摧意 = 1,
			龙魄 = 1,
			戏珠 = 1,
			龙珠 = 1,
			波涛 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"二龙戏珠",
			"亢龙归海",
			"雷浪穿云"
		}
	}
	战斗单位[4] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "大力金刚",
		名称 = "大力金刚",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			破空 = 1,
			念心 = 1,
			风刃 = 1,
			无敌 = 1,
			干将 = 1,
			勇念 = 1,
			杀意 = 1,
			破军 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"破釜沉舟",
			"横扫千军",
			"后发制人"
		}
	}
	战斗单位[5] = {
		不可封印 = true,
		愤怒 = 999,
		气血 = 300000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 1500,
		法防 = 1500,
		躲避 = 1000,
		伤害 = 5000,
		模型 = "大力金刚",
		名称 = "永住金刚",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			鹰啸 = 1,
			化血 = 1,
			狮吼 = 1,
			威震 = 1,
			宁息 = 1
		},
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"鹰击",
			"狮搏",
			"连环击"
		}
	}
	战斗单位[6] = {
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "大力金刚",
		名称 = "护法枷蓝",
		等级 = 等级,
		奇经八脉 = {
			毒引 = 1,
			倩影 = 1,
			毒雾 = 1,
			嫣然 = 1,
			磐石 = 1,
			轻霜 = 1,
			杏花 = 1,
			暗伤 = 1,
			天香 = 1,
			鸿影 = 1,
			花舞 = 1,
			自矜 = 1,
			淬芒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"碎玉弄影",
			"飞符炼魂",
			"一笑倾城"
		}
	}
	战斗单位[7] = {
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "大力金刚",
		名称 = "护法枷蓝",
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		奇经八脉 = {
			不倦 = 1,
			苦缠 = 1,
			化身 = 1,
			雷动 = 1,
			奔雷 = 1,
			鬼念 = 1,
			碎甲 = 1,
			批亢 = 1,
			鬼惧 = 1
		},
		技能 = {
			"高级反震",
			"高级感知",
			"高级驱鬼",
			"高级法术连击",
			"高级法术暴击",
			"高级反击",
			"高级夜战"
		},
		主动技能 = {
			"碎甲符",
			"定身符",
			"失心符",
			"五雷咒",
			"落雷符",
			"分身术"
		}
	}
	战斗单位[8] = {
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 3000,
		模型 = "大力金刚",
		名称 = "护法枷蓝 ",
		等级 = 等级,
		奇经八脉 = {
			普渡 = 1,
			借灵 = 1,
			道衍 = 1,
			雨润 = 1,
			秘术 = 1,
			法咒 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"普渡众生",
			"波澜不惊",
			"五行制化",
			"灵动九天"
		}
	}
	战斗单位[9] = {
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "大力金刚",
		名称 = "护法枷蓝 ",
		等级 = 等级,
		奇经八脉 = {
			脱壳 = 1,
			情劫 = 1,
			迷梦 = 1,
			鼓乐 = 1,
			结阵 = 1,
			粘附 = 1,
			媚态 = 1,
			迷意 = 1,
			妖气 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"含情脉脉",
			"瘴气",
			"魔音摄魂",
			"盘丝阵",
			"幻镜术",
			"天罗地网"
		}
	}
	战斗单位[10] = {
		气血 = 150000,
		变异 = true,
		魔法 = 99999900,
		灵力 = 3000,
		速度 = 1000,
		防御 = 3000,
		法防 = 3000,
		躲避 = 5000,
		伤害 = 5000,
		模型 = "大力金刚",
		名称 = "护法枷蓝 ",
		等级 = 等级,
		奇经八脉 = {
			乾坤 = 1,
			雨杀 = 1,
			修心 = 1,
			意境 = 1,
			傲视 = 1,
			陌宝 = 1,
			养生 = 1,
			锤炼 = 1,
			混元 = 1,
			心随意动 = 1,
			同辉 = 1,
			体恤 = 1,
			归本 = 1,
			致命 = 1,
			神附 = 1
		},
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级驱鬼",
			"高级必杀",
			"高级反击",
			"高级夜战",
			"高级反震"
		},
		主动技能 = {
			"日月乾坤",
			"飘渺式",
			"烟雨剑法",
			"生命之泉",
			"天命剑法"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取新服福利BOSS信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		躲避 = 4,
		速度 = 2.3,
		等级 = 0,
		防御 = 30,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7,
		气血 = 等级 * 25,
		灵力 = 等级 * 7.5,
		法防 = 等级 * 3,
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型范围 = {
		"超级玉兔"
	}
	local 模型名称范围 = {
		"新服福利BOSS"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 6 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			伤害 = 500,
			魔法 = 99999900,
			气血 = 1000,
			躲避 = 4,
			灵力 = 300,
			显示饰品 = true,
			速度 = 2.3,
			等级 = 0,
			防御 = 3,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			法防 = 等级 * 3,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取车迟斗法贡品信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 20

	if 等级 <= 10 then
		等级 = 10
	end

	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 10 + 200,
		气血 = 等级 * 75,
		灵力 = 等级 * 4,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型范围 = {
		"泡泡"
	}
	local 模型名称范围 = {
		"贡品"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 任务数据[任务id].名称,
			模型 = 模型,
			伤害 = 等级 * 5,
			气血 = 等级 * 75,
			灵力 = 等级 * 4,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	for i = 4, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 5,
			气血 = 等级 * 50,
			灵力 = 等级 * 4,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取车迟斗法三清信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		变异 = true,
		魔法 = 99999900,
		躲避 = 100,
		模型 = "大力金刚",
		名称 = 任务数据[任务id].名称,
		伤害 = 等级 * 10,
		气血 = 等级 * 等级,
		灵力 = 等级 * 4,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	等级 = 等级 - 5

	for i = 2, 10 do
		战斗单位[i] = {
			魔法 = 99999900,
			模型 = "天兵",
			名称 = "护法",
			伤害 = 等级 * 8,
			气血 = 等级 * 等级,
			灵力 = 等级 * 4,
			速度 = 等级 * 2.5,
			防御 = 等级 * 5,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"高级感知"
			},
			技能 = {
				"高级连击"
			},
			主动技能 = 取随机法术(2)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取车迟斗法求雨信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		变异 = true,
		魔法 = 99999900,
		躲避 = 100,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 15,
		气血 = 等级 * 等级,
		灵力 = 等级 * 7,
		速度 = 等级 * 3.5,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	for i = 2, 10 do
		战斗单位[i] = {
			魔法 = 99999900,
			模型 = "天将",
			名称 = "天将",
			伤害 = 等级 * 12,
			气血 = 等级 * 等级,
			灵力 = 等级 * 5,
			速度 = 等级 * 2.5,
			防御 = 等级 * 5,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 1.5),
			技能 = {
				"高级连击"
			},
			主动技能 = 取随机法术(2)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取车迟斗法不动信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)

	if 任务数据[任务id].名称 == "我不动" then
		战斗单位[1] = {
			变异 = true,
			魔法 = 99999900,
			躲避 = 100,
			模型 = "净瓶女娲",
			名称 = 任务数据[任务id].名称,
			伤害 = 等级 * 12,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 3.5,
			防御 = 等级 * 6,
			法防 = 等级 * 0.5,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"龙卷雨击",
				"龙腾"
			}
		}

		for i = 2, 5 do
			战斗单位[i] = {
				变异 = true,
				魔法 = 99999900,
				躲避 = 100,
				模型 = "净瓶女娲",
				名称 = "你不动",
				伤害 = 等级 * 8,
				气血 = 等级 * 等级,
				灵力 = 等级 * 8,
				速度 = 等级 * 2.5,
				防御 = 等级 * 4,
				法防 = 等级 * 0.5,
				等级 = 等级,
				攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
				防御修炼 = math.floor(取人物修炼等级上限1(等级)),
				法术修炼 = math.floor(取人物修炼等级上限1(等级)),
				抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
				技能 = {
					"高级夜战"
				},
				主动技能 = {
					"泰山压顶"
				}
			}
		end

		等级 = 等级 - 5

		for i = 6, 10 do
			战斗单位[i] = {
				魔法 = 99999900,
				模型 = "大力金刚",
				名称 = "护法",
				伤害 = 等级 * 10,
				气血 = 等级 * 等级,
				灵力 = 等级 * 4,
				速度 = 等级 * 2.5,
				防御 = 等级 * 4,
				法防 = 等级 * 0.5,
				躲避 = 等级 * 4,
				等级 = 等级,
				攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
				防御修炼 = math.floor(取人物修炼等级上限1(等级)),
				法术修炼 = math.floor(取人物修炼等级上限1(等级)),
				抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
				技能 = {
					"高级连击"
				},
				主动技能 = {}
			}
		end
	else
		战斗单位[1] = {
			变异 = true,
			魔法 = 99999900,
			躲避 = 100,
			模型 = "净瓶女娲",
			名称 = 任务数据[任务id].名称,
			伤害 = 等级 * 13,
			气血 = 等级 * 等级,
			灵力 = 等级 * 4,
			速度 = 等级 * 3.5,
			防御 = 等级 * 6,
			法防 = 等级 * 0.5,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"变身",
				"鹰击",
				"连环击"
			}
		}

		for i = 2, 5 do
			战斗单位[i] = {
				变异 = true,
				魔法 = 99999900,
				躲避 = 100,
				模型 = "大力金刚",
				名称 = "护法",
				伤害 = 等级 * 10,
				气血 = 等级 * 等级,
				灵力 = 等级 * 4,
				速度 = 等级 * 3.5,
				防御 = 等级 * 4,
				法防 = 等级 * 0.5,
				等级 = 等级,
				攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
				防御修炼 = math.floor(取人物修炼等级上限1(等级)),
				法术修炼 = math.floor(取人物修炼等级上限1(等级)),
				抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
				技能 = {
					"高级连击"
				},
				主动技能 = 取随机法术(2)
			}
		end

		等级 = 等级 - 5

		for i = 6, 10 do
			战斗单位[i] = {
				魔法 = 99999900,
				模型 = "夜罗刹",
				名称 = "护卫",
				伤害 = 等级 * 5,
				气血 = 等级 * 等级,
				灵力 = 等级 * 4,
				速度 = 等级 * 2.5,
				防御 = 等级 * 4,
				法防 = 等级 * 0.5,
				躲避 = 等级 * 4,
				等级 = 等级,
				攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
				防御修炼 = math.floor(取人物修炼等级上限1(等级)),
				法术修炼 = math.floor(取人物修炼等级上限1(等级)),
				抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
				技能 = {
					"高级连击"
				},
				主动技能 = {}
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取车迟斗法妖怪信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 模型范围 = {
		"进阶金身罗汉"
	}
	local 模型名称范围 = {
		"三妖精"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	战斗单位[1] = {
		魔法 = 99999900,
		饰品 = true,
		名称 = 模型名称范围[取随机数(1, #模型名称范围)],
		模型 = 模型,
		伤害 = 等级 * 10,
		气血 = (等级 - 5 + 等级 * 0.2) * 145,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 6,
		法防 = 等级 * 0.5,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"魔之心",
			"法术连击",
			"高级隐身"
		},
		主动技能 = {
			"龙卷雨击",
			"龙腾",
			"龙吟"
		}
	}
	local 模型范围 = {
		"踏云兽",
		"净瓶女娲",
		"炎魔神",
		"雨师",
		"芙蓉仙子"
	}
	local 模型名称范围 = {
		"喽啰"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 攻击技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"天雷斩"
		}
	}
	local 辅助技能范围 = {
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		}
	}
	local 技能随机 = 攻击技能范围[取随机数(1, #攻击技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 攻击技能范围[取随机数(1, #攻击技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 12,
			气血 = (等级 - 5 + 等级 * 0.2) * 130,
			灵力 = 等级 * 8,
			速度 = 等级 * 2.3,
			防御 = 等级 * 4,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	for i = 9, 10 do
		模型 = "灵符女娲"
		技能随机 = 辅助技能范围[取随机数(1, #辅助技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 8,
			气血 = (等级 - 5 + 等级 * 0.2) * 130,
			灵力 = 等级 * 4,
			速度 = 等级 * 2.3,
			防御 = 等级 * 4,
			法防 = 等级 * 0.5,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取散财童子信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		躲避 = 4,
		速度 = 2.3,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 10 + 300,
		气血 = 等级 * 100 + 3000,
		灵力 = 等级 * 10 + 100,
		防御 = 等级 * 5,
		法防 = 等级 * 3,
		等级 = 等级,
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	local 模型范围 = {
		"葫芦宝贝"
	}
	local 模型名称范围 = {
		"恭喜发财"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 6 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			躲避 = 4,
			显示饰品 = true,
			速度 = 2.3,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 10 + 300,
			气血 = 等级 * 50 + 3000,
			灵力 = 等级 * 10 + 100,
			防御 = 等级 * 5,
			法防 = 等级 * 3,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取神秘妖怪信息(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 战斗单位 = {
		{
			魔法 = 99999900,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			变异 = 任务数据[任务id].变异,
			显示饰品 = 任务数据[任务id].显示饰品,
			伤害 = 等级 * 8 + 500,
			气血 = 等级 * 300,
			灵力 = 等级 * 8 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 5,
			法防 = 等级 * 5,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	}
	local 模型范围 = {
		"蛟龙",
		"地狱战神",
		"白熊",
		"古代瑞兽"
	}
	local 模型名称范围 = {
		"喽罗"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 6 + 500,
			气血 = 等级 * 200,
			灵力 = 等级 * 6 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 5,
			法防 = 等级 * 5,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取妄空曰天冷信息(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 战斗单位 = {
		{
			角色 = true,
			魔法 = 99999900,
			速度 = 5.3,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
			武器染色组 = 任务数据[任务id].武器染色组,
			武器染色方案 = 任务数据[任务id].武器染色方案,
			变异 = 任务数据[任务id].变异,
			显示饰品 = 任务数据[任务id].显示饰品,
			伤害 = 等级 * 10 + 1000,
			气血 = 等级 * 400,
			灵力 = 等级 * 10 + 500,
			防御 = 等级 * 6,
			法防 = 等级 * 6,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	}
	local 模型范围 = {
		"进阶鬼将",
		"进阶蝎子精",
		"进阶吸血鬼",
		"进阶碧水夜叉",
		"进阶龙龟"
	}
	local 模型名称范围 = {
		"喽罗"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 8 + 500,
			气血 = 等级 * 300,
			灵力 = 等级 * 8 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 6,
			法防 = 等级 * 6,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取妄空曰天冷信息2(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 战斗单位 = {
		{
			角色 = true,
			魔法 = 99999900,
			速度 = 5.3,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			武器 = 取武器数据(任务数据[任务id].武器, 任务数据[任务id].武器等级),
			武器染色组 = 任务数据[任务id].武器染色组,
			武器染色方案 = 任务数据[任务id].武器染色方案,
			变异 = 任务数据[任务id].变异,
			显示饰品 = 任务数据[任务id].显示饰品,
			伤害 = 等级 * 10 + 1000,
			气血 = 等级 * 400,
			灵力 = 等级 * 10 + 500,
			防御 = 等级 * 6,
			法防 = 等级 * 6,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	}
	local 模型名称范围 = {
		"喽罗"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, #Q_随机模型)]
		local 武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			角色 = true,
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			武器染色组 = 任务数据[任务id].武器染色组,
			武器染色方案 = 任务数据[任务id].武器染色方案,
			伤害 = 等级 * 8 + 500,
			气血 = 等级 * 300,
			灵力 = 等级 * 8 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 6,
			法防 = 等级 * 6,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取渡劫师傅信息(任务id, 玩家id)
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 模型 = 玩家数据[玩家id].角色.数据.造型
	local 武器造型 = 取天罡星武器造型(模型)
	local 战斗单位 = {
		{
			气血 = 300000,
			角色 = true,
			魔法 = 200000,
			灵力 = 1500,
			速度 = 800,
			防御 = 1000,
			法防 = 1000,
			伤害 = 2500,
			名称 = 玩家数据[玩家id].角色.数据.门派 .. "大弟子",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			武器染色组 = 任务数据[任务id].武器染色组,
			武器染色方案 = 任务数据[任务id].武器染色方案,
			变异 = 任务数据[任务id].变异,
			显示饰品 = 任务数据[任务id].显示饰品,
			躲避 = 等级 * 5,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	}
	local 模型名称范围 = {
		"喽罗"
	}
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"二龙戏珠"
		},
		{
			"落叶萧萧",
			"泰山压顶",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 10 do
		local 模型 = Q_随机模型[取随机数(1, 5)]

		if 玩家数据[玩家id].角色.数据.种族 == "仙" then
			模型 = Q_随机模型[取随机数(6, 10)]
		elseif 玩家数据[玩家id].角色.数据.种族 == "魔" then
			模型 = Q_随机模型[取随机数(11, 15)]
		end

		武器造型 = 取天罡星武器造型(模型)
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			气血 = 100000,
			角色 = true,
			魔法 = 200000,
			灵力 = 1000,
			显示饰品 = true,
			速度 = 800,
			防御 = 800,
			法防 = 800,
			伤害 = 2000,
			名称 = 玩家数据[玩家id].角色.数据.门派 .. "弟子",
			模型 = 模型,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			武器染色组 = 任务数据[任务id].武器染色组,
			武器染色方案 = 任务数据[任务id].武器染色方案,
			躲避 = 等级 * 5,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:首席争霸(任务id, 玩家id, 假人属性)
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) + 5
	local 假人随机阵法 = {
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 战斗单位 = {
		{
			气血 = 20000,
			角色 = true,
			魔法 = 99999900,
			灵力 = 1000,
			速度 = 500,
			防御 = 500,
			法防 = 500,
			躲避 = 100,
			伤害 = 1000,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			武器 = 取武器数据(首席争霸[Q_门派编号[任务数据[任务id].序列]].武器, 首席争霸[Q_门派编号[任务数据[任务id].序列]].武器等级),
			染色组 = 首席争霸[Q_门派编号[任务数据[任务id].序列]].染色组,
			染色方案 = 首席争霸[Q_门派编号[任务数据[任务id].序列]].染色方案,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = Q_门派法术[Q_门派编号[任务数据[任务id].序列]]
		},
		阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]
	}

	for i = 2, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 150,
				名称 = 假人属性[i].名称,
				模型 = 临时数据.模型,
				伤害 = math.floor(假人属性[i].伤害 * 1.5),
				气血 = math.floor(假人属性[i].气血 * 10),
				灵力 = math.floor(假人属性[i].灵力 * 1.5),
				速度 = math.floor(假人属性[i].速度 * 1),
				防御 = math.floor(假人属性[i].防御 * 1),
				法防 = math.floor(假人属性[i].法防 * 1),
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能1(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(65, 假人属性[i].参战等级)[2]
			战斗单位[i] = {
				名称 = 模型名称,
				模型 = 模型名称,
				伤害 = math.floor(假人属性[i].伤害 * 1.5),
				气血 = math.floor(假人属性[i].气血 * 5),
				灵力 = math.floor(假人属性[i].灵力 * 1.5),
				速度 = math.floor(假人属性[i].速度 * 1),
				防御 = math.floor(假人属性[i].防御 * 1),
				法防 = math.floor(假人属性[i].法防 * 1),
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取蚩尤幻影信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		变异 = true,
		伤害 = 4550,
		名称 = "蚩尤幻影",
		模型 = 任务数据[任务id].模型,
		气血 = (等级 * 等级 * 20 + 400000) * 1.3,
		灵力 = 等级 * 8 * 1.3,
		速度 = 等级 * 6 * 1.3,
		防御 = 等级 * 6 * 1.3,
		法防 = 等级 * 6 * 1.3,
		躲避 = 等级 * 6 * 1.3,
		魔法 = 等级 * 500 * 10 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		法防 = 500,
		伤害 = 4290,
		模型 = "进阶夜罗刹",
		名称 = "魔族护法",
		气血 = (等级 * 等级 * 15 + 200000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		速度 = 等级 * 3 * 1.3,
		防御 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[3] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		法防 = 500,
		伤害 = 4290,
		模型 = "进阶曼珠沙华",
		名称 = "魔族军师",
		气血 = (等级 * 等级 * 15 + 200000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		速度 = 等级 * 3 * 1.3,
		防御 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}
	战斗单位[4] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "进阶蝎子精",
		名称 = "魔族首领",
		伤害 = 等级 * 5 * 1.3,
		气血 = (等级 * 等级 * 15 + 200000) * 1.3,
		灵力 = (等级 * 15 + 300) * 1.3,
		速度 = 等级 * 2 * 1.3,
		防御 = 等级 * 3 * 1.3,
		法防 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[5] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "进阶蝎子精",
		名称 = "魔族首领",
		伤害 = 等级 * 5 * 1.3,
		气血 = (等级 * 等级 * 15 + 200000) * 1.3,
		灵力 = (等级 * 15 + 300) * 1.3,
		速度 = 等级 * 2 * 1.3,
		防御 = 等级 * 3 * 1.3,
		法防 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[6] = {
		变异 = true,
		魔法 = 99999900,
		模型 = "进阶混沌兽",
		名称 = "魔族精英",
		伤害 = 等级 * 5 * 1.3,
		气血 = (等级 * 等级 * 15 + 200000) * 1.3,
		灵力 = (等级 * 15 + 300) * 1.3,
		速度 = 等级 * 2 * 1.3,
		防御 = 等级 * 3 * 1.3,
		法防 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"落叶萧萧",
			"八凶法阵",
			"上古灵符",
			"龙卷雨击",
			"龙吟"
		}
	}
	战斗单位[7] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		速度 = 1040,
		伤害 = 780,
		模型 = "进阶琴仙",
		名称 = "魔族精英",
		气血 = (等级 * 等级 * 15 + 150000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		防御 = 等级 * 3 * 1.3,
		法防 = 等级 * 3.8 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[8] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		速度 = 1040,
		伤害 = 780,
		模型 = "进阶琴仙",
		名称 = "魔族精英",
		气血 = (等级 * 等级 * 15 + 150000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		防御 = 等级 * 3 * 1.3,
		法防 = 等级 * 3.8 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"失心符",
			"定身符",
			"反间之计"
		}
	}
	战斗单位[9] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		伤害 = 780,
		模型 = "进阶龙龟",
		名称 = "魔族精英",
		气血 = (等级 * 等级 * 25 + 400000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		速度 = 等级 * 2.5 * 1.3,
		防御 = 等级 * 6 * 1.3,
		法防 = 等级 * 6 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"推气过宫",
			"四海升平",
			"罗汉金钟",
			"晶清诀"
		}
	}
	战斗单位[10] = {
		愤怒 = 99999,
		变异 = true,
		魔法 = 99999900,
		伤害 = 2990,
		模型 = "进阶蜃气妖",
		名称 = "魔族精英",
		气血 = (等级 * 等级 * 15 + 150000) * 1.3,
		灵力 = 等级 * 4 * 1.3,
		速度 = 等级 * 4 * 1.3,
		防御 = 等级 * 5 * 1.3,
		法防 = 等级 * 3.5 * 1.3,
		躲避 = 等级 * 4 * 1.3,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = {
			"横扫千军",
			"善恶有报",
			"壁垒击破",
			"剑荡四方",
			"天雷斩",
			"破血狂攻",
			"破碎无双"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取福利宝箱怪(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = math.max(取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5, 5)
	local 模型范围 = {
		"虾兵",
		"蟹将"
	}
	local 名称 = "秘制麻辣小龙虾"
	模型 = 模型范围[取随机数(1, #模型范围)]

	if 模型 == "蟹将" then
		名称 = "火爆干锅梭子蟹"
	end

	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 名称,
		模型 = 模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30 + 1000,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"海毛虫",
		"大海龟",
		"海星",
		"章鱼"
	}
	local 模型名称范围 = {
		"清蒸",
		"红烧",
		"炭烤",
		"油炸",
		"生吃"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 取随机数(3, 5) do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			变异 = true,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 20 + 500,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取倾国倾城信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 3000,
		变异 = true,
		法防 = 10000,
		躲避 = 2000,
		灵力 = 5000,
		伤害 = 5000,
		速度 = 800,
		防御 = 10000,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		等级 = 等级,
		技能 = {
			"高级隐身",
			"嗜血追击",
			"苍鸾怒击",
			"高级连击",
			"高级必杀",
			"高级吸血"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"炎魔神"
	}
	local 模型名称范围 = {
		"抠脚大汉"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 4 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 100000,
			变异 = true,
			法防 = 5000,
			灵力 = 800,
			伤害 = 1500,
			速度 = 0,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			防御 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	模型范围 = {
		"花妖"
	}
	local 模型名称范围 = {
		"侍女"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 5, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			愤怒 = 9999,
			气血 = 50000,
			变异 = true,
			伤害 = 1500,
			速度 = 0,
			防御 = 1000,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			灵力 = 等级 * 5,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"四海升平",
				"失魂符"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取美食专家信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 5000,
		变异 = true,
		灵力 = 600,
		伤害 = 1000,
		速度 = 0,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"魔之心",
			"法术连击"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"山贼",
		"赌徒",
		"强盗"
	}
	local 模型名称范围 = {
		"贪吃的食客"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 5000,
			变异 = true,
			灵力 = 600,
			伤害 = 1000,
			速度 = 0,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天塔信息(任务id, 玩家id, 假人属性)
	local 假人随机阵法 = {
		"普通",
		"天覆阵",
		"地载阵",
		"风扬阵",
		"云垂阵",
		"龙飞阵",
		"虎翼阵",
		"鸟翔阵",
		"蛇蟠阵",
		"鹰啸阵",
		"雷绝阵"
	}
	local 通天塔层数 = 通天塔数据[玩家id].层数
	local 等级 = 取队伍最高等级数(玩家数据[玩家id].队伍, 玩家id)

	if 通天塔层数 == nil then
		通天塔层数 = 0
	end

	if 通天塔层数 >= 0 and 通天塔层数 < 999 then
		self.难度系数 = 1 + 通天塔层数 / 15
	end

	local 战斗单位 = {
		阵法 = 假人随机阵法[取随机数(1, #假人随机阵法)]
	}

	for i = 1, #假人属性 do
		if 假人属性[i].门派 ~= nil then
			local 临时数据 = self:取剑会天下随机属性(假人属性[i].门派, 假人属性[i].等级)
			local 武器数据 = 取可佩带武器名称1(临时数据.模型, 假人属性[i].等级)
			战斗单位[i] = {
				愤怒 = 9999,
				名称 = "通天" .. 通天塔层数 + 1 .. "层统领",
				模型 = 临时数据.模型,
				伤害 = 等级 * 6 * self.难度系数,
				气血 = 等级 * 等级 * self.难度系数,
				灵力 = 等级 * 4 * self.难度系数,
				速度 = 等级 * 2 * self.难度系数,
				防御 = 等级 * 3 * self.难度系数,
				法防 = 等级 * 2 * self.难度系数,
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = {},
				主动技能 = 临时数据.技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				武器 = 取武器数据(武器数据[1], 武器数据[2]),
				五维属性 = 假人属性[i].五维属性,
				门派 = 临时数据.门派,
				奇经八脉 = 临时数据.奇经八脉,
				附加状态 = 临时数据.附加状态,
				追加法术 = 临时数据.追加法术,
				武器伤害 = 假人属性[i].武器伤害,
				法宝 = 临时数据.法宝
			}
		else
			local 临时数据 = self:取剑会天下BB技能(假人属性[i].五维属性, 假人属性[i].技能)
			local 模型名称 = 取随机怪(125, 假人属性[i].参战等级)[2]
			战斗单位[i] = {
				名称 = 模型名称,
				模型 = 模型名称,
				伤害 = 等级 * 5 * self.难度系数,
				气血 = 等级 * 等级 * self.难度系数,
				灵力 = 等级 * 3 * self.难度系数,
				速度 = 等级 * 2 * self.难度系数,
				防御 = 等级 * 2 * self.难度系数,
				法防 = 等级 * self.难度系数,
				躲避 = 假人属性[i].等级 * 2,
				魔法 = 假人属性[i].魔法 + 2000,
				等级 = 假人属性[i].等级,
				技能 = 临时数据.技能,
				主动技能 = 临时数据.主动技能,
				位置 = 假人属性[i].位置,
				攻击修炼 = 假人属性[i].攻击修炼,
				防御修炼 = 假人属性[i].防御修炼,
				法术修炼 = 假人属性[i].法术修炼,
				抗法修炼 = 假人属性[i].抗法修炼,
				角色分类 = 假人属性[i].角色分类,
				五维属性 = 假人属性[i].五维属性,
				内丹数据 = 假人属性[i].内丹数据,
				追加法术 = 临时数据.追加法术
			}
		end
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取贼王的线索信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 2 + 取队伍人数(玩家id)

	for n = 1, 数量 do
		战斗单位[n] = {
			气血 = 30000,
			魔法 = 99999900,
			灵力 = 3500,
			速度 = 500,
			伤害 = 1000,
			模型 = "骷髅怪",
			名称 = "帮凶",
			等级 = 175,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 2,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(4)
		}
	end

	战斗单位[1] = {
		气血 = 30000,
		魔法 = 99999900,
		灵力 = 3500,
		速度 = 500,
		伤害 = 1000,
		模型 = "吸血鬼",
		名称 = "贼王",
		等级 = 175,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取貔貅的羁绊信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 数量 = 7
	local 造型范围 = {
		"老虎",
		"黑熊"
	}
	local 造型 = 造型范围[取随机数(1, #造型范围)]

	for n = 1, 数量 do
		战斗单位[n] = {
			气血 = 2000,
			魔法 = 99999900,
			速度 = 0,
			伤害 = 1100,
			名称 = "帮凶",
			等级 = 175,
			模型 = 造型,
			灵力 = 等级 * 5,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 2,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级鬼魂术"
			},
			主动技能 = 取随机法术(4)
		}
	end

	战斗单位[1] = {
		气血 = 10000,
		魔法 = 99999900,
		速度 = 0,
		防御 = 3000,
		伤害 = 2000,
		模型 = "帮派妖兽",
		名称 = "貔貅",
		等级 = 175,
		灵力 = 等级 * 5,
		法防 = 等级 * 3,
		躲避 = 等级 * 2,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆桃木虫信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 1000,
		变异 = true,
		灵力 = 600,
		伤害 = 100,
		速度 = 0,
		模型 = "海毛虫",
		名称 = "桃木虫",
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"蝴蝶仙子"
	}
	local 模型名称范围 = {
		"桃木虫喽罗"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 1000,
			变异 = true,
			灵力 = 600,
			伤害 = 80,
			速度 = 0,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆泼猴信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 1000,
		变异 = true,
		灵力 = 600,
		伤害 = 80,
		速度 = 0,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"长眉灵猴"
	}
	local 模型名称范围 = {
		"猴虱"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 1000,
			灵力 = 600,
			伤害 = 80,
			速度 = 0,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 技能随机
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆翼虎必死信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 1000000000000.0,
		变异 = true,
		法防 = 99999999,
		躲避 = 99999999,
		灵力 = 99999999,
		伤害 = 9999999,
		速度 = 99999999,
		防御 = 999999999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		等级 = 等级,
		技能 = {
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"龙卷雨击",
			"飞砂走石",
			"三昧真火"
		}
	}
	模型范围 = {
		"老虎"
	}
	local 模型名称范围 = {
		"虎军师"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 1000000000000.0,
			变异 = true,
			法防 = 99999999,
			躲避 = 99999999,
			灵力 = 99999999,
			伤害 = 9999999,
			速度 = 99999999,
			防御 = 999999999,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			等级 = 等级,
			技能 = {
				"高级魔之心",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"龙卷雨击",
				"飞砂走石",
				"三昧真火"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆蝰蛇必死信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 5
	战斗单位[1] = {
		魔法 = 99999900,
		气血 = 1000000000000.0,
		变异 = true,
		法防 = 99999999,
		躲避 = 99999999,
		灵力 = 99999999,
		伤害 = 9999999,
		速度 = 99999999,
		防御 = 999999999,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		等级 = 等级,
		技能 = {
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = {
			"龙卷雨击",
			"飞砂走石",
			"三昧真火"
		}
	}
	模型范围 = {
		"灵符女娲"
	}
	local 模型名称范围 = {
		"蛇军师"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			气血 = 1000000000000.0,
			变异 = true,
			法防 = 99999999,
			躲避 = 99999999,
			灵力 = 99999999,
			伤害 = 9999999,
			速度 = 99999999,
			防御 = 999999999,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			等级 = 等级,
			技能 = {
				"高级魔之心",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"龙卷雨击",
				"飞砂走石",
				"三昧真火"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆翼虎信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 10,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"老虎"
	}
	local 模型名称范围 = {
		"虎精兵"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 6,
			灵力 = 等级 * 3,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"龙卷雨击",
				"飞砂走石",
				"三昧真火"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆蝰蛇信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"灵符女娲"
	}
	local 模型名称范围 = {
		"蛇精兵"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆巡山小妖信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"雷鸟人"
	}
	local 模型名称范围 = {
		"巡山喽罗"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 7 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆毒虫信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"海毛虫"
	}
	local 模型名称范围 = {
		"毒虫"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆上古妖兽头领信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 等级,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"吸血鬼"
	}
	local 模型名称范围 = {
		"妖巫师"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 2 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级隐身"
			},
			主动技能 = 取随机法术(5)
		}
	end

	模型范围 = {
		"蜘蛛精"
	}
	local 模型名称范围 = {
		"妖兽精兵"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 3, 7 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆妖将军信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 等级,
		灵力 = 等级 * 10,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"蜘蛛精"
	}
	local 模型名称范围 = {
		"护法金刚"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 6 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	模型范围 = {
		"幽灵"
	}
	local 模型名称范围 = {
		"妖护法"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 7, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级隐身"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取水陆魑魅魍魉信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	模型范围 = {
		"帮派妖兽"
	}
	local 模型名称范围 = {
		"魑魅魍魉"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		名称 = 模型名称范围[取随机数(1, #模型名称范围)],
		模型 = 模型,
		伤害 = 等级 * 5 + 500,
		气血 = 等级 * 等级,
		灵力 = 等级 * 10 + 500,
		速度 = 等级 * 8,
		防御 = 等级 * 8,
		法防 = 等级 * 8,
		躲避 = 等级 * 8,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	模型范围 = {
		"百足将军"
	}
	local 模型名称范围 = {
		"妖王护法"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 3 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10 + 500,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	模型范围 = {
		"黑熊精"
	}
	local 模型名称范围 = {
		"妖护卫"
	}
	模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 4, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			名称 = 模型名称范围[取随机数(1, #模型名称范围)],
			模型 = 模型,
			伤害 = 等级 * 1 + 500,
			气血 = 等级 * 等级,
			灵力 = 等级 * 10,
			速度 = 等级 * 4,
			防御 = 等级 * 4,
			法防 = 等级 * 4,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取捣乱的年兽信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 15,
		气血 = 等级 * 100 + 8000,
		灵力 = 等级 * 10 + 300,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级夜战",
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		变异 = true,
		模型 = "蛟龙",
		名称 = "赤金蛟龙",
		伤害 = 等级 * 10,
		气血 = 等级 * 60,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级夜战"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[3] = {
		变异 = true,
		模型 = "蛟龙",
		名称 = "赤金蛟龙",
		伤害 = 等级 * 10,
		气血 = 等级 * 60,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级夜战"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[4] = {
		变异 = true,
		模型 = "龙龟",
		名称 = "碧玉王八",
		伤害 = 等级 * 10,
		气血 = 等级 * 60,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级魔之心"
		},
		主动技能 = Q_门派法术.魔王寨
	}
	战斗单位[5] = {
		变异 = true,
		模型 = "龙龟",
		名称 = "碧玉王八",
		伤害 = 等级 * 10,
		气血 = 等级 * 60,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 6,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级魔之心"
		},
		主动技能 = Q_门派法术.龙宫
	}

	for n = 6, 10 do
		战斗单位[n] = {
			变异 = true,
			模型 = "兔子怪",
			名称 = "闹事妖精",
			伤害 = 等级 * 10,
			气血 = 等级 * 60,
			灵力 = 等级 * 8,
			速度 = 等级 * 2,
			防御 = 等级 * 6,
			法防 = 等级 * 6,
			躲避 = 等级 * 10,
			魔法 = 等级 * 500 * 10,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
			技能 = {
				"魔之心",
				"必杀"
			},
			主动技能 = 取随机法术(3)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取年兽王信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		伤害 = 等级 * 12,
		气血 = 等级 * 150 + 10000,
		灵力 = 等级 * 10,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	战斗单位[2] = {
		变异 = true,
		模型 = "毗舍童子",
		名称 = "福瑞灵兽",
		伤害 = 等级 * 12,
		气血 = 等级 * 等级 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 6,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[3] = {
		变异 = true,
		模型 = "毗舍童子",
		名称 = "福瑞灵兽",
		伤害 = 等级 * 12,
		气血 = 等级 * 等级 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 6,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = Q_门派法术.大唐官府
	}
	战斗单位[4] = {
		变异 = true,
		模型 = "炎魔神",
		名称 = "福祉灵兽",
		伤害 = 等级 * 8,
		气血 = 等级 * 等级 + 10000,
		灵力 = 等级 * 10,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = Q_门派法术.魔王寨
	}
	战斗单位[5] = {
		变异 = true,
		模型 = "炎魔神",
		名称 = "福祉灵兽",
		伤害 = 等级 * 8,
		气血 = 等级 * 等级 + 10000,
		灵力 = 等级 * 10,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知",
			"高级魔之心",
			"高级法术连击",
			"高级法术暴击"
		},
		主动技能 = Q_门派法术.龙宫
	}
	战斗单位[6] = {
		变异 = true,
		模型 = "大力金刚",
		名称 = "护宝灵使",
		伤害 = 等级 * 8,
		气血 = 等级 * 4 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[7] = {
		变异 = true,
		模型 = "大力金刚",
		名称 = "护宝灵使",
		伤害 = 等级 * 8,
		气血 = 等级 * 4 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[8] = {
		变异 = true,
		模型 = "大力金刚",
		名称 = "护宝灵使",
		伤害 = 等级 * 8,
		气血 = 等级 * 4 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[9] = {
		变异 = true,
		模型 = "大力金刚",
		名称 = "护宝灵使",
		伤害 = 等级 * 8,
		气血 = 等级 * 4 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}
	战斗单位[10] = {
		变异 = true,
		模型 = "大力金刚",
		名称 = "护宝灵使",
		伤害 = 等级 * 8,
		气血 = 等级 * 4 + 10000,
		灵力 = 等级 * 8,
		速度 = 等级 * 2,
		防御 = 等级 * 6,
		法防 = 等级 * 3,
		躲避 = 等级 * 10,
		魔法 = 等级 * 500 * 10,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		防御修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		法术修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级) / 2),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(3)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取怨灵幻影信息(任务id, 玩家id)
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 战斗单位 = {
		{
			变异 = true,
			名称 = 任务数据[任务id].名称,
			模型 = 任务数据[任务id].模型,
			伤害 = 等级 * 12 * 2 + 800,
			气血 = 等级 * 等级 * 5 * 2 + 45000,
			灵力 = 等级 * 8 * 2,
			速度 = 等级 * 3.5 * 2,
			防御 = 等级 * 5 * 2,
			法防 = 等级 * 5 * 2,
			躲避 = 等级 * 6 * 2,
			魔法 = 等级 * 500 * 6 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		},
		{
			变异 = true,
			模型 = "超级神龙",
			名称 = "怨灵幻影",
			伤害 = 等级 * 10 * 2 + 800,
			气血 = 等级 * 等级 * 4 * 2 + 30000,
			灵力 = 等级 * 4 * 2,
			速度 = 等级 * 3.5 * 2,
			防御 = 等级 * 4 * 2,
			法防 = 等级 * 3 * 2,
			躲避 = 等级 * 4 * 2,
			魔法 = 等级 * 500 * 4 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		},
		{
			变异 = true,
			模型 = "超级神兔",
			名称 = "怨灵幻影",
			伤害 = 等级 * 10 * 2 + 800,
			气血 = 等级 * 等级 * 4 * 2 + 30000,
			灵力 = 等级 * 4 * 2,
			速度 = 等级 * 3.5 * 2,
			防御 = 等级 * 4 * 2,
			法防 = 等级 * 3 * 2,
			躲避 = 等级 * 4 * 2,
			魔法 = 等级 * 500 * 4 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		},
		{
			变异 = true,
			模型 = "超级神羊",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 4 * 2 + 30000,
			灵力 = 等级 * 8 * 2 + 300,
			速度 = 等级 * 1.5 * 2,
			防御 = 等级 * 3 * 2,
			法防 = 等级 * 4 * 2,
			躲避 = 等级 * 4 * 2,
			魔法 = 等级 * 500 * 4 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级魔之心",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"三昧真火",
				"地狱烈火",
				"飞砂走石"
			}
		},
		{
			变异 = true,
			模型 = "超级神牛",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 4 * 2 + 30000,
			灵力 = 等级 * 8 * 2 + 300,
			速度 = 等级 * 1.5 * 2,
			防御 = 等级 * 3 * 2,
			法防 = 等级 * 4 * 2,
			躲避 = 等级 * 4 * 2,
			魔法 = 等级 * 500 * 4 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级魔之心",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"龙卷雨击",
				"龙腾",
				"龙吟",
				"二龙戏珠"
			}
		},
		{
			变异 = true,
			模型 = "超级神猴",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 4 * 2 + 30000,
			灵力 = 等级 * 8 * 2 + 300,
			速度 = 等级 * 1.5 * 2,
			防御 = 等级 * 3 * 2,
			法防 = 等级 * 4 * 2,
			躲避 = 等级 * 4 * 2,
			魔法 = 等级 * 500 * 4 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知",
				"高级魔之心",
				"高级法术连击",
				"高级法术暴击"
			},
			主动技能 = {
				"落叶萧萧",
				"雷击",
				"奔雷咒"
			}
		},
		{
			变异 = true,
			模型 = "超级人参娃娃",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 4 * 2 + 20000,
			灵力 = 等级 * 8 * 2,
			速度 = 等级 * 5 * 2,
			防御 = 等级 * 3 * 2,
			法防 = 等级 * 4 * 2,
			躲避 = 等级 * 5 * 2,
			魔法 = 等级 * 500 * 5 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"失心符",
				"定身符",
				"反间之计"
			}
		},
		{
			变异 = true,
			模型 = "超级土地公公",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 4 * 2 + 20000,
			灵力 = 等级 * 8 * 2,
			速度 = 等级 * 5 * 2,
			防御 = 等级 * 3 * 2,
			法防 = 等级 * 4 * 2,
			躲避 = 等级 * 5 * 2,
			魔法 = 等级 * 500 * 5 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"失心符",
				"定身符",
				"反间之计"
			}
		},
		{
			愤怒 = 99999,
			变异 = true,
			模型 = "超级神蛇",
			名称 = "怨灵幻影",
			伤害 = 等级 * 5 * 2,
			气血 = 等级 * 等级 * 8 * 2 + 20000,
			灵力 = 等级 * 8 * 2,
			速度 = 等级 * 2.5 * 2,
			防御 = 等级 * 8 * 2,
			法防 = 等级 * 6 * 2,
			躲避 = 等级 * 8 * 2,
			魔法 = 等级 * 500 * 5 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"推气过宫",
				"金刚护体",
				"普渡众生",
				"金刚护法",
				"晶清诀",
				"罗汉金钟",
				"四海升平"
			}
		},
		{
			变异 = true,
			模型 = "超级麒麟",
			名称 = "怨灵幻影",
			伤害 = 等级 * 12 * 2 + 1000,
			气血 = 等级 * 等级 * 4 * 2 + 20000,
			灵力 = 等级 * 4 * 2,
			速度 = 等级 * 3.5 * 2,
			防御 = 等级 * 4 * 2,
			法防 = 等级 * 3 * 2,
			躲避 = 等级 * 5 * 2,
			魔法 = 等级 * 500 * 5 * 2,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级隐身",
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"善恶有报",
				"烟雨剑法",
				"天雷斩",
				"飘渺式"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取灵感分身信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	战斗单位[1] = {
		角色 = true,
		魔法 = 99999900,
		模型 = "神天兵",
		名称 = "灵感分身",
		武器 = 取武器数据("雷神", 100),
		伤害 = 等级 * 12 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 8,
		速度 = 等级 * 4.5,
		防御 = 等级 * 4,
		法防 = 等级 * 3.8,
		躲避 = 等级 * 4,
		等级 = 等级,
		攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
		防御修炼 = math.floor(取人物修炼等级上限1(等级)),
		法术修炼 = math.floor(取人物修炼等级上限1(等级)),
		抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天河妖信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"蚌精",
		"鲛人",
		"碧水夜叉",
		"大海龟",
		"章鱼",
		"虾兵",
		"蟹将",
		"海星"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = "河妖",
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天散财童子信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"净瓶女娲"
	}
	local 名称范围 = {
		"炎上",
		"润下",
		"稼穑"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天黑熊精信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		名称 = 任务数据[任务id].名称,
		模型 = 任务数据[任务id].模型,
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 等级,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"净瓶女娲"
	}
	local 名称范围 = {
		"炎上",
		"润下",
		"稼穑"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 8 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天五色竹条信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		模型 = "泡泡",
		名称 = "竹精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"泡泡"
	}
	local 名称范围 = {
		"竹精"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天金鱼将军1信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "野鬼",
		名称 = "红色鱼精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"蚌精",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天金鱼将军2信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "地狱战神",
		名称 = "黄色鱼精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"虾兵",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天金鱼将军3信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "鬼将",
		名称 = "黑色鱼精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"虾兵",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天金鱼将军4信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "鲛人",
		名称 = "白色鱼精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 150,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"蟹将",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天金鱼将军5信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id) - 2
	战斗单位[1] = {
		魔法 = 99999900,
		变异 = true,
		模型 = "蚌精",
		名称 = "蓝色鱼精",
		显示饰品 = 任务数据[任务id].显示饰品,
		伤害 = 等级 * 7 + 500,
		气血 = 等级 * 30,
		灵力 = 等级 * 4 + 300,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}
	等级 = 等级 - 10
	local 模型范围 = {
		"蟹将",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 2, 5 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			显示饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 5 + 500,
			气血 = 等级 * 30,
			灵力 = 等级 * 4 + 300,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:取通天灵感大王信息(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 取队伍平均等级(玩家数据[玩家id].队伍, 玩家id)
	local 模型范围 = {
		"神天兵"
	}
	local 名称范围 = {
		"灵感大王"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	战斗单位[1] = {
		饰品 = true,
		角色 = true,
		变异 = true,
		魔法 = 99999900,
		名称 = 名称,
		模型 = 模型,
		武器 = 取武器数据("五虎断魂", 140),
		伤害 = 等级 * 10 + 800,
		气血 = 等级 * 100,
		灵力 = 等级 * 7 + 500,
		速度 = 等级 * 2.3,
		防御 = 等级 * 3,
		法防 = 等级 * 3,
		躲避 = 等级 * 4,
		等级 = 等级,
		技能 = {
			"高级感知"
		},
		主动技能 = 取随机法术(5)
	}

	for i = 2, 5 do
		战斗单位[i] = {
			角色 = true,
			魔法 = 99999900,
			模型 = "神天兵",
			名称 = "灵感分身",
			武器 = 取武器数据("五虎断魂", 100),
			伤害 = 等级 * 8 + 200,
			气血 = 等级 * 300,
			灵力 = 等级 * 5 + 300,
			速度 = 等级 * 4.5,
			防御 = 等级 * 4,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			攻击修炼 = math.floor(取人物修炼等级上限1(等级)),
			防御修炼 = math.floor(取人物修炼等级上限1(等级)),
			法术修炼 = math.floor(取人物修炼等级上限1(等级)),
			抗法修炼 = math.floor(取人物修炼等级上限1(等级)),
			技能 = {
				"高级感知"
			},
			主动技能 = 取随机法术(5)
		}
	end

	等级 = 等级 - 10
	local 模型范围 = {
		"蟹将",
		"龟丞相"
	}
	local 名称范围 = {
		"通天妖将",
		"通天师爷"
	}
	local 模型 = 模型范围[取随机数(1, #模型范围)]
	local 名称 = 名称范围[取随机数(1, #名称范围)]
	local 技能范围 = {
		{
			"横扫千军",
			"善恶有报"
		},
		{
			"三昧真火",
			"地狱烈火",
			"飞砂走石"
		},
		{
			"龙卷雨击",
			"龙腾",
			"龙吟"
		},
		{
			"落叶萧萧",
			"雷击",
			"奔雷咒"
		},
		{
			"失心符",
			"定身符",
			"反间之计"
		},
		{
			"推气过宫"
		},
		{
			"天雷斩"
		}
	}
	local 技能随机 = 技能范围[取随机数(1, #技能范围)]

	for i = 6, 10 do
		模型 = 模型范围[取随机数(1, #模型范围)]
		名称 = 名称范围[取随机数(1, #名称范围)]
		技能随机 = 技能范围[取随机数(1, #技能范围)]
		战斗单位[i] = {
			魔法 = 99999900,
			饰品 = true,
			名称 = 名称,
			模型 = 模型,
			伤害 = 等级 * 10 + 500,
			气血 = 等级 * 50,
			灵力 = 等级 * 5 + 500,
			速度 = 等级 * 2.3,
			防御 = 等级 * 3,
			法防 = 等级 * 3,
			躲避 = 等级 * 4,
			等级 = 等级,
			技能 = {
				"魔之心",
				"法术连击"
			},
			主动技能 = 取随机法术(5)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:虎子战斗(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 2000,
			法防 = 1,
			躲避 = 100,
			灵力 = 1,
			伤害 = 150,
			速度 = 50,
			模型 = "僵尸",
			名称 = "僵尸虎子",
			等级 = 10,
			防御 = 10,
			技能 = {
				"必杀"
			},
			主动技能 = {
				"尸腐毒",
				"判官令",
				"高级连击"
			}
		},
		{
			魔法 = 9999990,
			气血 = 1500,
			法防 = 1,
			躲避 = 100,
			灵力 = 1,
			伤害 = 100,
			速度 = 50,
			模型 = "幽灵",
			名称 = "迷惘幽灵",
			等级 = 10,
			防御 = 10,
			技能 = {
				"必杀"
			},
			主动技能 = {
				"横扫千军",
				"后发制人"
			}
		},
		{
			魔法 = 9999990,
			气血 = 1500,
			法防 = 1,
			躲避 = 100,
			灵力 = 150,
			伤害 = 250,
			速度 = 50,
			模型 = "骷髅怪",
			名称 = "海边妖怪",
			等级 = 10,
			防御 = 10,
			技能 = {
				"魔之心",
				"反击"
			},
			主动技能 = {
				"水攻",
				"高级连击"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战灵鹤(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 2000,
			法防 = 150,
			躲避 = 100,
			灵力 = 150,
			伤害 = 300,
			速度 = 100,
			模型 = "灵鹤",
			名称 = "三清",
			等级 = 20,
			防御 = 100,
			技能 = {
				"高级法术暴击"
			},
			主动技能 = {
				"五雷轰顶",
				"雷霆万钧",
				"地狱烈火"
			}
		},
		{
			魔法 = 9999990,
			气血 = 500,
			法防 = 10,
			躲避 = 100,
			灵力 = 100,
			伤害 = 300,
			速度 = 100,
			模型 = "灵鹤",
			名称 = "三清分身",
			等级 = 20,
			防御 = 10,
			技能 = {
				"法术暴击"
			},
			主动技能 = {
				"烈火"
			}
		},
		{
			魔法 = 9999990,
			气血 = 500,
			法防 = 10,
			躲避 = 100,
			灵力 = 100,
			伤害 = 300,
			速度 = 100,
			模型 = "灵鹤",
			名称 = "三清分身",
			等级 = 20,
			防御 = 10,
			技能 = {
				"法术暴击"
			},
			主动技能 = {
				"烈火"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战灵鹤2(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 3000,
			法防 = 50,
			躲避 = 100,
			灵力 = 50,
			伤害 = 250,
			速度 = 100,
			模型 = "进阶灵鹤",
			名称 = "三清真身",
			等级 = 20,
			防御 = 200,
			技能 = {
				"必杀"
			},
			主动技能 = {
				"天神护法",
				"天雷斩",
				"金刚镯"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战江南小盗(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 3000,
			法防 = 100,
			躲避 = 100,
			灵力 = 100,
			伤害 = 350,
			速度 = 150,
			模型 = "强盗",
			名称 = "江南小盗",
			等级 = 20,
			防御 = 150,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级反击"
			},
			主动技能 = {
				"高级连击",
				"力劈华山",
				"善恶有报"
			}
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			魔法 = 9999990,
			气血 = 1000,
			法防 = 50,
			躲避 = 100,
			灵力 = 100,
			伤害 = 300,
			速度 = 100,
			模型 = "山贼",
			名称 = "江南小小盗",
			等级 = 20,
			防御 = 100,
			技能 = {
				"高级连击",
				"必杀",
				"高级反击"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战大大龟(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 8000,
			法防 = 100,
			躲避 = 100,
			灵力 = 100,
			伤害 = 400,
			速度 = 150,
			模型 = "大海龟",
			名称 = "大大龟",
			等级 = 20,
			防御 = 200,
			技能 = {
				"高级反震",
				"高级再生"
			},
			主动技能 = {
				"壁垒击破",
				"剑荡四方"
			}
		},
		{
			魔法 = 9999990,
			气血 = 5000,
			法防 = 50,
			躲避 = 100,
			灵力 = 100,
			伤害 = 350,
			速度 = 100,
			模型 = "海毛虫",
			名称 = "果毛虫",
			等级 = 20,
			防御 = 150,
			技能 = {
				"高级连击",
				"高级必杀",
				"高级毒",
				"嗜血追击"
			},
			主动技能 = {}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战绿皮蛙(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			气血 = 8000,
			法防 = 100,
			躲避 = 100,
			灵力 = 400,
			伤害 = 400,
			速度 = 200,
			模型 = "巨蛙",
			名称 = "绿皮蛙",
			等级 = 20,
			防御 = 100,
			技能 = {
				"高级法术暴击",
				"高级法术连击"
			},
			主动技能 = {
				"水攻",
				"水漫金山"
			}
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 3000,
			变异 = true,
			法防 = 50,
			躲避 = 100,
			灵力 = 100,
			伤害 = 300,
			速度 = 100,
			模型 = "巨蛙",
			名称 = "绿皮蛙分身",
			等级 = 20,
			防御 = 100,
			技能 = {},
			主动技能 = {
				"烟雨剑法",
				"弱点击破"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战屈原(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			不可封印 = true,
			气血 = 15000,
			法防 = 150,
			躲避 = 100,
			灵力 = 150,
			伤害 = 300,
			速度 = 150,
			模型 = "地藏王",
			名称 = "屈原",
			等级 = 30,
			防御 = 150,
			技能 = {
				"高级法术暴击",
				"高级法术连击"
			},
			主动技能 = {
				"阎罗令",
				"尸腐毒",
				"判官令"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战狂盗(任务id, 玩家id)
	local 战斗单位 = {
		{
			魔法 = 9999990,
			不可封印 = true,
			气血 = 15000,
			变异 = true,
			法防 = 150,
			躲避 = 100,
			灵力 = 150,
			伤害 = 500,
			速度 = 150,
			模型 = "强盗",
			名称 = "狂盗",
			等级 = 30,
			防御 = 150,
			技能 = {
				"高级必杀",
				"高级吸血"
			},
			主动技能 = {
				"变身",
				"狮搏",
				"鹰击",
				"连环击"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战黄狮王(任务id, 玩家id)
	local 战斗单位 = {
		{
			躲避 = 999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 99999,
			角色 = true,
			法防 = 999,
			灵力 = 999,
			伤害 = 999,
			速度 = 999,
			模型 = "巨魔王",
			名称 = "黄狮王",
			等级 = 99,
			防御 = 999,
			武器 = 取武器数据("五丁开山", 140),
			技能 = {
				"高级法术暴击"
			},
			主动技能 = {
				"摇头摆尾",
				"无敌牛虱"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战马全有(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 30000,
			法防 = 100,
			躲避 = 100,
			灵力 = 100,
			伤害 = 650,
			速度 = 150,
			模型 = "山贼",
			名称 = "马全有",
			等级 = 30,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"破血狂攻",
				"狮搏",
				"鹰击",
				"连环击"
			}
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 15000,
			变异 = true,
			法防 = 10,
			躲避 = 100,
			灵力 = 500,
			伤害 = 500,
			速度 = 150,
			模型 = "海毛虫",
			名称 = "被抓的海毛虫",
			等级 = 30,
			防御 = 200,
			技能 = {
				"驱鬼"
			},
			主动技能 = 取随机法术(10)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战海盗头子(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 30000,
			法防 = 100,
			躲避 = 100,
			灵力 = 100,
			伤害 = 700,
			速度 = 150,
			模型 = "强盗",
			名称 = "海绵宝宝 ",
			等级 = 40,
			防御 = 250,
			技能 = {
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"天崩地裂",
				"翻江搅海",
				"善恶有报"
			}
		},
		{
			愤怒 = 99999,
			魔法 = 9999990,
			气血 = 30000,
			法防 = 100,
			躲避 = 100,
			灵力 = 500,
			伤害 = 300,
			速度 = 150,
			模型 = "海星",
			名称 = "派大星",
			等级 = 40,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"推气过宫",
				"唧唧歪歪"
			}
		},
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 30000,
			法防 = 100,
			躲避 = 100,
			灵力 = 500,
			伤害 = 300,
			速度 = 70,
			模型 = "章鱼",
			名称 = "章鱼哥 ",
			等级 = 40,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"失心符",
				"失魂符",
				"定身符",
				"夜舞倾城"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:梦战浪鬼(任务id, 玩家id)
	local 战斗单位 = {}
	local 随机阵法 = {
		"天覆阵"
	}
	战斗单位.阵法 = 随机阵法[取随机数(1, #随机阵法)]
	战斗单位[1] = {
		愤怒 = 99999,
		魔法 = 9999990,
		不可封印 = true,
		气血 = 30000,
		法防 = 100,
		躲避 = 100,
		灵力 = 100,
		伤害 = 700,
		速度 = 200,
		模型 = "进阶夜罗刹",
		名称 = "浪鬼",
		等级 = 40,
		防御 = 250,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"雨落寒沙",
			"死亡召唤",
			"满天花雨"
		}
	}
	战斗单位[2] = {
		愤怒 = 99999,
		魔法 = 9999990,
		气血 = 20000,
		法防 = 100,
		躲避 = 100,
		灵力 = 500,
		伤害 = 600,
		速度 = 150,
		模型 = "夜罗刹",
		名称 = "浪妖",
		等级 = 35,
		防御 = 200,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军"
		}
	}
	战斗单位[3] = {
		愤怒 = 99999,
		魔法 = 9999990,
		气血 = 20000,
		法防 = 100,
		躲避 = 100,
		灵力 = 500,
		伤害 = 600,
		速度 = 150,
		模型 = "夜罗刹",
		名称 = "浪妖 ",
		等级 = 35,
		防御 = 200,
		技能 = {
			"高级感知"
		},
		主动技能 = {
			"横扫千军"
		}
	}

	for n = 4, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 10000,
			法防 = 100,
			躲避 = 100,
			灵力 = 500,
			伤害 = 500,
			速度 = 150,
			模型 = "镜妖",
			名称 = "浪女",
			等级 = 30,
			防御 = 200,
			技能 = {
				"驱鬼"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:洛树妖(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 10000,
			变异 = true,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 200,
			模型 = "树怪",
			名称 = "洛树妖",
			等级 = 45,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"地狱烈火",
				"烈火",
				"八凶法阵"
			}
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 5000,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 150,
			模型 = "树怪",
			名称 = "树怪喽啰",
			等级 = 45,
			防御 = 200,
			技能 = {
				"驱鬼"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:赌徒喽啰(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 10000,
			变异 = true,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 200,
			模型 = "赌徒",
			名称 = "赌徒大喽啰",
			等级 = 45,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"横扫千军",
				"破釜沉舟",
				"后发制人"
			}
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 5000,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 150,
			模型 = "赌徒",
			名称 = "赌徒小喽啰",
			等级 = 45,
			防御 = 200,
			技能 = {
				"驱鬼"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:江州县令(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 10000,
			变异 = true,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 200,
			模型 = "护卫",
			名称 = "江州衙役",
			等级 = 45,
			防御 = 250,
			技能 = {
				"高级感知"
			},
			主动技能 = {
				"天崩地裂",
				"翻江搅海",
				"浪涌"
			}
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 5000,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 150,
			模型 = "护卫",
			名称 = "江州衙役",
			等级 = 45,
			防御 = 200,
			技能 = {
				"驱鬼"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:江洋大盗(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 50000,
			变异 = true,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 1000,
			速度 = 500,
			模型 = "强盗",
			名称 = "江洋大盗",
			等级 = 59,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = {
				"变身",
				"狮搏",
				"鹰击",
				"天雷斩"
			}
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 10000,
			法防 = 100,
			躲避 = 100,
			灵力 = 700,
			伤害 = 800,
			速度 = 500,
			模型 = "强盗",
			名称 = "江洋小盗",
			等级 = 59,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:洛川鬼(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 100000,
			变异 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "骷髅怪",
			名称 = "洛川鬼",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级再生",
				"高级吸血",
				"高级鬼魂"
			},
			主动技能 = {
				"阎罗令",
				"尸腐毒",
				"六道无量"
			}
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 50000,
			法防 = 1,
			躲避 = 100,
			灵力 = 100,
			伤害 = 1300,
			速度 = 500,
			模型 = "僵尸",
			名称 = "魔族小鬼",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级鬼魂"
			},
			主动技能 = {
				"百爪狂杀",
				"六道无量",
				"判官令"
			}
		}
	end

	for n = 4, 5 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 50000,
			法防 = 1,
			躲避 = 100,
			灵力 = 1200,
			伤害 = 1000,
			速度 = 500,
			模型 = "野鬼",
			名称 = "魔族小妖",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级鬼魂"
			},
			主动技能 = {
				"水漫金山",
				"地狱烈火",
				"泰山压顶",
				"奔雷咒"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:妩媚狐仙(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 200000,
			变异 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "狐狸精",
			名称 = "妩媚狐仙",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级鬼魂",
				"凝光炼彩"
			},
			主动技能 = {
				"天罗地网",
				"偷龙转凤",
				"善恶有报"
			}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:赌霸城(任务id, 玩家id)
	local 战斗单位 = {
		{
			气血 = 200000,
			不可封印 = true,
			愤怒 = 99999,
			变异 = true,
			魔法 = 9999990,
			灵力 = 1200,
			速度 = 500,
			防御 = 500,
			法防 = 1,
			躲避 = 100,
			伤害 = 1800,
			模型 = "赌徒",
			名称 = "赌霸城",
			等级 = 79,
			追加法术 = {
				{
					名称 = "飞砂走石",
					概率 = 50,
					等级 = 79
				}
			},
			技能 = {
				"高级感知",
				"高级法术暴击",
				"苍鸾怒击",
				"嗜血追击",
				"理直气壮",
				"高级必杀"
			},
			主动技能 = {}
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:半阁守将(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 100000,
			变异 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 100,
			伤害 = 1800,
			速度 = 500,
			模型 = "天将",
			名称 = "半阁守将",
			等级 = 79,
			防御 = 100,
			技能 = {
				"高级感知",
				"高级必杀",
				"高级驱鬼",
				"高级吸血",
				"高级反击",
				"高级反震",
				"高级幸运"
			},
			主动技能 = {
				"天雷斩"
			}
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			不可封印 = true,
			气血 = 50000,
			法防 = 1,
			躲避 = 100,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "天兵",
			名称 = "半阁守兵",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级幸运",
				"高级吸血"
			},
			主动技能 = {
				"横扫千军",
				"力劈华山",
				"善恶有报"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:流氓兔(任务id, 玩家id)
	local 战斗单位 = {}

	for n = 1, 10 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			气血 = 50000,
			法防 = 1,
			躲避 = 100,
			灵力 = 1,
			伤害 = 1500,
			速度 = 100,
			模型 = "兔子怪",
			名称 = "流氓兔",
			等级 = 79,
			防御 = 800,
			技能 = {
				"高级感知",
				"高级驱鬼",
				"高级必杀",
				"高级幸运",
				"高级吸血"
			},
			主动技能 = {
				"龙吟"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大雁塔塔主(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 100000,
			法防 = 1,
			躲避 = 100,
			灵力 = 1300,
			伤害 = 1800,
			速度 = 500,
			模型 = "风伯",
			名称 = "大雁塔塔主",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"风卷残云",
				"落叶萧萧",
				"冰川怒"
			}
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			不可封印 = true,
			气血 = 50000,
			法防 = 1,
			躲避 = 100,
			灵力 = 1300,
			伤害 = 1500,
			速度 = 500,
			模型 = "雷鸟人",
			名称 = "守护神鸟",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"奔雷咒",
				"雷击"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大雁塔塔主2(任务id, 玩家id)
	local 战斗单位 = {
		{
			愤怒 = 99999,
			魔法 = 9999990,
			不可封印 = true,
			气血 = 80000,
			变异 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 1400,
			伤害 = 1800,
			速度 = 500,
			模型 = "风伯",
			名称 = "大雁塔塔主",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"风卷残云",
				"落叶萧萧",
				"冰川怒"
			}
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			不可封印 = true,
			气血 = 30000,
			饰品 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 1400,
			伤害 = 1500,
			速度 = 500,
			模型 = "雷鸟人",
			名称 = "守护神鸟",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"奔雷咒",
				"雷击"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:大雁塔塔主3(任务id, 玩家id)
	local 战斗单位 = {
		{
			气血 = 60000,
			不可封印 = true,
			愤怒 = 99999,
			变异 = true,
			魔法 = 9999990,
			饰品 = true,
			灵力 = 1600,
			速度 = 700,
			防御 = 500,
			法防 = 1,
			躲避 = 100,
			伤害 = 1800,
			模型 = "进阶风伯",
			名称 = "大雁塔塔主",
			等级 = 79,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"风卷残云",
				"落叶萧萧"
			}
		}
	}

	for n = 2, 3 do
		战斗单位[n] = {
			魔法 = 9999990,
			愤怒 = 99999,
			不可封印 = true,
			气血 = 10000,
			饰品 = true,
			法防 = 1,
			躲避 = 100,
			灵力 = 1600,
			伤害 = 1500,
			速度 = 700,
			模型 = "进阶雷鸟人",
			名称 = "守护神鸟",
			等级 = 69,
			防御 = 500,
			技能 = {
				"高级感知",
				"高级法术连击",
				"高级法术暴击",
				"高级驱鬼"
			},
			主动技能 = {
				"奔雷咒"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:卷帘大将1(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 100000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "狮驼岭",
		饰品 = true,
		灵力 = 100,
		速度 = 800,
		防御 = 800,
		法防 = 1,
		躲避 = 999,
		伤害 = 1600,
		模型 = "沙僧",
		名称 = "卷帘大将",
		等级 = 79,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级吸血",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"变身",
			"鹰击",
			"狮搏",
			"连环击"
		}
	}

	for n = 2, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			门派 = "天宫",
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "天兵",
			名称 = "天兵喽罗",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"天雷斩"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:卷帘大将2(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		魔法 = 99999900,
		饰品 = true,
		不可封印 = true,
		气血 = 1000000000000.0,
		门派 = "狮驼岭",
		法防 = 99999999,
		躲避 = 99999999,
		灵力 = 99999999,
		伤害 = 9999999,
		速度 = 99999999,
		模型 = "沙僧",
		名称 = "卷帘大将(心魔)",
		等级 = 79,
		防御 = 999999999,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级吸血",
			"高级驱鬼",
			"高级幸运",
			"高级审判"
		},
		主动技能 = {
			"扶摇万里"
		}
	}

	for n = 2, 6 do
		战斗单位[n] = {
			魔法 = 99999900,
			门派 = "天宫",
			气血 = 1000000000000.0,
			法防 = 99999999,
			躲避 = 99999999,
			灵力 = 99999999,
			伤害 = 9999999,
			速度 = 99999999,
			模型 = "天兵",
			名称 = "天兵喽罗",
			等级 = 79,
			防御 = 999999999,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"天雷斩"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:路人甲(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 100000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "女儿村",
		饰品 = true,
		灵力 = 100,
		速度 = 800,
		防御 = 500,
		法防 = 1,
		躲避 = 999,
		伤害 = 1500,
		模型 = "赌徒",
		名称 = "路人甲",
		等级 = 79,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级反击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"雨落寒沙",
			"满天花雨"
		}
	}
	战斗单位[2] = {
		不可封印 = true,
		气血 = 50000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "化生寺",
		饰品 = true,
		灵力 = 800,
		速度 = 500,
		防御 = 1000,
		法防 = 1,
		躲避 = 999,
		伤害 = 1000,
		模型 = "花妖",
		名称 = "花妖喽罗",
		等级 = 79,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"推气过宫",
			"唧唧歪歪"
		}
	}

	for n = 3, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			门派 = "女儿村",
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 100,
			伤害 = 1300,
			速度 = 500,
			模型 = "雷鸟人",
			名称 = "雷鸟人喽啰",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"飞花摘叶",
				"满天花雨",
				"似玉生香"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:杨戬(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 100000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "天宫",
		饰品 = true,
		灵力 = 1000,
		速度 = 800,
		防御 = 500,
		法防 = 1,
		躲避 = 999,
		伤害 = 1500,
		模型 = "天兵",
		名称 = "撒豆成兵",
		等级 = 79,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级反击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"天雷斩",
			"错乱",
			"地狱烈火"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 50000,
		门派 = "普陀山",
		法防 = 1,
		躲避 = 999,
		灵力 = 800,
		伤害 = 1000,
		速度 = 500,
		模型 = "天兵",
		名称 = "天兵喽罗",
		等级 = 79,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"普渡众生",
			"日光华"
		}
	}

	for n = 3, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 800,
			伤害 = 1300,
			速度 = 500,
			模型 = "天兵",
			名称 = "天兵喽罗",
			等级 = 79,
			防御 = 100,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = 取随机法术(15)
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:龙孙(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 100000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "龙宫",
		饰品 = true,
		灵力 = 1200,
		速度 = 800,
		防御 = 500,
		法防 = 1,
		躲避 = 999,
		伤害 = 1500,
		模型 = "蛟龙",
		名称 = "龙孙",
		等级 = 79,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"龙卷雨击",
			"水漫金山",
			"龙腾"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 50000,
		门派 = "五庄观",
		法防 = 1,
		躲避 = 999,
		灵力 = 1,
		伤害 = 1300,
		速度 = 500,
		模型 = "虾兵",
		名称 = "虾兵喽啰",
		等级 = 79,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"生命之泉",
			"日月乾坤",
			"飘渺式"
		}
	}

	for n = 3, 5 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 1000,
			伤害 = 1300,
			速度 = 500,
			模型 = "龟丞相",
			名称 = "龟丞相喽啰",
			等级 = 79,
			防御 = 100,
			技能 = {
				"高级法术连击",
				"高级感知",
				"高级法术暴击",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"龙卷雨击",
				"水漫金山",
				"龙腾"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:卷帘大将3(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		不可封印 = true,
		气血 = 150000,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "狮驼岭",
		饰品 = true,
		灵力 = 100,
		速度 = 800,
		防御 = 800,
		法防 = 1,
		躲避 = 999,
		伤害 = 2000,
		模型 = "沙僧",
		名称 = "卷帘大将(心魔)",
		等级 = 79,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级吸血",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"变身",
			"鹰击",
			"狮搏",
			"连环击"
		}
	}

	for n = 2, 6 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			门派 = "天宫",
			气血 = 80000,
			法防 = 1,
			躲避 = 999,
			灵力 = 100,
			伤害 = 1500,
			速度 = 500,
			模型 = "天兵",
			名称 = "天兵喽罗",
			等级 = 79,
			防御 = 500,
			技能 = {
				"高级必杀",
				"高级感知",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"天雷斩"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:角色69突破战斗(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位.阵法 = "虎翼阵"
	战斗单位[4] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "大唐官府",
		法防 = 700,
		躲避 = 999,
		灵力 = 1000,
		伤害 = 2000,
		速度 = 800,
		模型 = "程咬金",
		名称 = "程咬金",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"破釜沉舟",
			"横扫千军",
			"杀气诀"
		}
	}
	战斗单位[5] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "凌波城",
		法防 = 800,
		躲避 = 999,
		灵力 = 1000,
		伤害 = 2000,
		速度 = 700,
		模型 = "二郎神",
		名称 = "二郎神",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"翻江搅海",
			"天崩地裂"
		}
	}
	战斗单位[6] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "狮驼岭",
		法防 = 800,
		躲避 = 999,
		灵力 = 1000,
		伤害 = 2000,
		速度 = 700,
		模型 = "大大王",
		名称 = "大大王",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"变身",
			"鹰击",
			"连环击"
		}
	}
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "龙宫",
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "东海龙王",
		名称 = "东海龙王",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"龙卷雨击",
			"二龙戏珠",
			"亢龙归海"
		}
	}
	战斗单位[2] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "魔王寨",
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "牛魔王",
		名称 = "牛魔王",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"摇头摆尾",
			"火甲术",
			"飞砂走石"
		}
	}
	战斗单位[3] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "神木林",
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "巫奎虎",
		名称 = "巫奎虎",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"风卷残云",
			"落叶萧萧",
			"雾杀"
		}
	}
	战斗单位[7] = {
		愤怒 = 9999,
		魔法 = 9999,
		门派 = "化生寺",
		气血 = 20000,
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "空度禅师",
		名称 = "空度禅师",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"金刚护法",
			"金刚护体"
		}
	}
	战斗单位[8] = {
		愤怒 = 9999,
		魔法 = 9999,
		门派 = "无底洞",
		气血 = 20000,
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "地涌夫人",
		名称 = "地涌夫人",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"夺命咒",
			"地涌金莲"
		}
	}
	战斗单位[9] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "五庄观",
		法防 = 800,
		躲避 = 999,
		灵力 = 2000,
		伤害 = 2000,
		速度 = 700,
		模型 = "镇元大仙",
		名称 = "镇元大仙",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级必杀",
			"高级感知",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"飘渺式",
			"日月乾坤",
			"日月乾坤",
			"日月乾坤"
		}
	}
	战斗单位[10] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 20000,
		门派 = "女儿村",
		法防 = 800,
		躲避 = 999,
		灵力 = 1500,
		伤害 = 3000,
		速度 = 700,
		模型 = "孙婆婆",
		名称 = "孙婆婆",
		等级 = 109,
		防御 = 1000,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"雨落寒沙",
			"一笑倾城",
			"一笑倾城",
			"一笑倾城"
		}
	}

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:空慈方丈(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	local 武器造型 = 取天罡星武器造型(模型)
	local 模型 = "逍遥生"
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 9999,
		不可封印 = true,
		气血 = 50000,
		门派 = "化生寺",
		法防 = 500,
		躲避 = 999,
		灵力 = 2000,
		伤害 = 2000,
		速度 = 800,
		模型 = "空度禅师",
		名称 = "空慈方丈",
		等级 = 79,
		防御 = 500,
		技能 = {
			"高级法术连击",
			"高级感知",
			"高级法术暴击",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"唧唧歪歪",
			"推气过宫",
			"破碎无双",
			"惊心一剑"
		}
	}

	for n = 2, 10 do
		武器造型 = 取天罡星武器造型(模型)
		战斗单位[n] = {
			气血 = 30000,
			魔法 = 9999,
			愤怒 = 999,
			角色 = true,
			门派 = "化生寺",
			灵力 = 2000,
			速度 = 600,
			防御 = 500,
			法防 = 500,
			躲避 = 999,
			伤害 = 2000,
			模型 = "逍遥生",
			名称 = "化生寺弟子",
			等级 = 79,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			技能 = {
				"高级法术连击",
				"高级感知",
				"高级法术暴击",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"唧唧歪歪",
				"牛刀小试",
				"金刚护体",
				"金刚护法"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:王福来(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		气血 = 50000,
		不可封印 = true,
		魔法 = 9999,
		愤怒 = 9999,
		门派 = "狮驼岭",
		灵力 = 2000,
		速度 = 500,
		防御 = 300,
		法防 = 300,
		躲避 = 999,
		伤害 = 2500,
		模型 = "大大王",
		名称 = "王福来",
		等级 = 79,
		附加状态 = {
			{
				等级 = 89,
				名称 = "变身"
			}
		},
		技能 = {
			"高级必杀",
			"高级感知",
			"高级吸血",
			"高级驱鬼",
			"高级幸运"
		},
		主动技能 = {
			"变身",
			"鹰击",
			"狮搏",
			"连环击"
		}
	}

	for n = 2, 10 do
		local 武器造型 = {
			级别 = 90,
			武器 = "八卦"
		}
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			气血 = 30000,
			角色 = true,
			门派 = "狮驼岭",
			灵力 = 2000,
			速度 = 450,
			防御 = 300,
			法防 = 300,
			躲避 = 999,
			伤害 = 2300,
			模型 = "虎头怪",
			名称 = "魔族弟子",
			等级 = 79,
			武器 = 取武器数据(武器造型.武器, 武器造型.级别),
			附加状态 = {
				{
					等级 = 89,
					名称 = "变身"
				}
			},
			技能 = {
				"高级必杀",
				"高级感知",
				"高级吸血",
				"高级驱鬼",
				"高级幸运"
			},
			主动技能 = {
				"变身",
				"鹰击",
				"象形"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:蓝火兽(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 99999,
		不可封印 = true,
		气血 = 80000,
		变异 = true,
		法防 = 1,
		躲避 = 999,
		灵力 = 2000,
		伤害 = 2500,
		速度 = 600,
		模型 = "古代瑞兽",
		名称 = "蓝火兽",
		等级 = 79,
		防御 = 1,
		技能 = {
			"高级法术暴击",
			"高级法术连击",
			"高级反震",
			"高级土属性吸收",
			"高级火属性吸收",
			"高级雷属性吸收",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级驱鬼",
			"高级感知"
		},
		主动技能 = {
			"泰山压顶",
			"食指大动"
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			气血 = 50000,
			法防 = 1,
			躲避 = 999,
			灵力 = 2000,
			伤害 = 2300,
			速度 = 500,
			模型 = "古代瑞兽",
			名称 = "红火兽",
			等级 = 79,
			防御 = 1,
			技能 = {
				"高级法术暴击",
				"高级法术连击",
				"高级反震",
				"高级土属性吸收",
				"高级火属性吸收",
				"高级雷属性吸收",
				"高级幸运",
				"高级神迹",
				"高级招架",
				"高级永恒",
				"高级驱鬼",
				"高级感知"
			},
			主动技能 = {
				"泰山压顶"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:吸血蝙蝠(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		愤怒 = 9999,
		魔法 = 99999,
		不可封印 = true,
		气血 = 80000,
		变异 = true,
		法防 = 800,
		躲避 = 999,
		灵力 = 2000,
		伤害 = 2500,
		速度 = 600,
		模型 = "大蝙蝠",
		名称 = "吸血蝙蝠",
		等级 = 79,
		防御 = 800,
		技能 = {
			"高级必杀",
			"高级吸血",
			"高级反击",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级驱鬼",
			"高级隐身"
		},
		主动技能 = {
			"剑荡四方"
		}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			气血 = 50000,
			法防 = 800,
			躲避 = 999,
			灵力 = 2000,
			伤害 = 2300,
			速度 = 500,
			模型 = "大蝙蝠",
			名称 = "大蝙蝠",
			等级 = 79,
			防御 = 800,
			技能 = {
				"高级必杀",
				"高级吸血",
				"高级反击",
				"高级幸运",
				"高级神迹",
				"高级招架",
				"高级永恒",
				"高级驱鬼",
				"高级隐身"
			},
			主动技能 = {
				"剑荡四方"
			}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

function 战斗准备类:肾宝狼(任务id, 玩家id)
	local 战斗单位 = {}
	local 等级 = 玩家数据[玩家id].角色.数据.等级
	战斗单位[1] = {
		躲避 = 999,
		普攻躲避率 = 50,
		愤怒 = 9999,
		气血 = 100000,
		变异 = true,
		魔法 = 99999,
		灵力 = 2000,
		速度 = 600,
		防御 = 500,
		法防 = 500,
		不可封印 = true,
		伤害 = 3000,
		模型 = "狼",
		名称 = "肾宝狼",
		等级 = 79,
		追加法术 = {
			{
				名称 = "剑荡四方",
				概率 = 40,
				等级 = 175
			}
		},
		技能 = {
			"高级必杀",
			"苍鸾怒击",
			"高级连击",
			"高级幸运",
			"高级神迹",
			"高级招架",
			"高级永恒",
			"高级驱鬼",
			"高级偷袭"
		},
		主动技能 = {}
	}

	for n = 2, 10 do
		战斗单位[n] = {
			愤怒 = 999,
			魔法 = 9999,
			普攻躲避率 = 30,
			气血 = 50000,
			法防 = 500,
			躲避 = 999,
			灵力 = 2000,
			伤害 = 3000,
			速度 = 500,
			模型 = "狼",
			名称 = "狼",
			等级 = 79,
			防御 = 500,
			追加法术 = {
				{
					名称 = "剑荡四方",
					概率 = 40,
					等级 = 175
				}
			},
			技能 = {
				"高级必杀",
				"苍鸾怒击",
				"高级连击",
				"高级幸运",
				"高级神迹",
				"高级招架",
				"高级永恒",
				"高级驱鬼",
				"高级偷袭"
			},
			主动技能 = {}
		}
	end

	return 全局战斗难度调整(战斗单位)
end

return 战斗准备类
